tests.py 21.7 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
        dir = join(self.env.test_dir, get_test_dirname(type))
Johannes Bechberger's avatar
Johannes Bechberger committed
44 45 46
        if exists(dir):
            self._load_test_case_dir(type, dir)
        else:
Johannes Bechberger's avatar
Johannes Bechberger committed
47
            _LOG.info("Test folder {} doesn't exist".format(dir))
Johannes Bechberger's avatar
Johannes Bechberger committed
48 49 50 51 52 53

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

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

    def _add_correct_test_case(self, test_case: 'TestCase'):
107
        self.correct_test_cases[test_case.type].add(basename(test_case.file))
Johannes Bechberger's avatar
Johannes Bechberger committed
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127

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

            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
143 144 145 146 147 148 149 150 151
            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
152 153 154 155
        return RunResult(count, failed)

    def _func(self, test_case: 'TestCase'):
        ret = self._run_test_case(test_case)
Johannes Bechberger's avatar
Johannes Bechberger committed
156
        if ret is not False and ret.is_correct():
157 158
            return 0, test_case
        return 1, test_case
Johannes Bechberger's avatar
Johannes Bechberger committed
159 160 161 162

    def _run_parallel(self, mode: str, parallel_jobs: int) -> RunResult:
        pool = multiprocessing.Pool(parallel_jobs)
        rets = pool.map(self._func, self.test_cases[mode])
163 164 165 166 167 168
        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
169 170 171 172 173 174 175
    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"]) +
176
                  colored(ret.short_message(), color))
Johannes Bechberger's avatar
Johannes Bechberger committed
177
            try:
178
                if self.env.produce_reports and (self.env.produce_all_reports or not ret.is_correct()):
179 180 181 182
                    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):
183 184 185 186
                        try:
                            os.mkdir(rep_dir)
                        except IOError:
                            pass
187 188
                    suffix = ".correct" if ret.is_correct() else ".incorrect"
                    ret.store_at(join(rep_dir, test_case.short_name() + suffix))
189 190 191
                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
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
                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
207 208 209 210
                try:
                    os.mkdir(os.path.dirname(log_file))
                except IOError:
                    pass
Johannes Bechberger's avatar
Johannes Bechberger committed
211 212 213 214 215 216 217 218 219 220 221
                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
222
    TEST_CASE_CLASSES = dict((k, []) for k in TEST_MODES)
Johannes Bechberger's avatar
Johannes Bechberger committed
223
    FILE_ENDINGS = []
Johannes Bechberger's avatar
Johannes Bechberger committed
224
    INVALID_FILE_ENDINGS = []
Johannes Bechberger's avatar
Johannes Bechberger committed
225

226
    def __init__(self, env: Environment, type: str, file: str, preprocessed_file: str):
Johannes Bechberger's avatar
Johannes Bechberger committed
227 228 229
        self.env = env
        self.type = type
        self.file = file
230
        self.preprocessed_file = preprocessed_file
Johannes Bechberger's avatar
Johannes Bechberger committed
231 232 233 234 235 236

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

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

    @classmethod
250
    def create_from_file(cls, env: Environment, mode: str, file: str, preprocessed_file: str) -> Optional['TestCase']:
251
        if cls.has_valid_file_ending(env.mode, file):
252
            return cls._test_case_class_for_file(env.mode, file)(env, mode, file, preprocessed_file)
Johannes Bechberger's avatar
Johannes Bechberger committed
253 254 255 256 257 258 259 260 261 262 263
        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]:
264
            if t.is_file_ending_valid(t, file):
Johannes Bechberger's avatar
Johannes Bechberger committed
265 266 267 268 269 270 271 272
                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

273 274 275 276 277 278 279 280 281 282 283 284 285
    @staticmethod
    def is_file_ending_valid(cls, file: str):
        return any(file.endswith(e) for e in cls.FILE_ENDINGS) and \
               not any(file.endswith(e) for e in cls.INVALID_FILE_ENDINGS)


    @staticmethod
    def _get_test_case_file(cls, file: str) -> Optional[str]:
        return file

    @classmethod
    def get_test_case_file(cls,  env: Environment, file: str) -> Optional[str]:
        return cls._test_case_class_for_file(env.mode, file)._get_test_case_file(cls, file)
Johannes Bechberger's avatar
Johannes Bechberger committed
286 287 288 289 290 291 292 293 294 295 296 297 298 299

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):
300
        os.makedirs(os.path.dirname(file), exist_ok=True)
Johannes Bechberger's avatar
Johannes Bechberger committed
301 302 303 304 305 306 307 308 309 310
        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()


311 312 313 314 315 316 317 318
class ExtensibleTestResult(TestResult):

    def __init__(self, test_case: TestCase):
        super().__init__(test_case, None)
        self.messages = []  # type: List[TestResultMessage]
        self.incorrect_msg = None  # type: Optional[str]
        self.has_succeeded = True  # type: bool
        self._contains_error_str = True  # type: bool
319
        self.correct_msg = "correct" # type: str
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349

    def add_error_output(self, title: str, error_output: str):
        """
        Checks for "error" string
        """
        self._contains_error_str = self._contains_error_str and error_output is not None and "error" in error_output
        self.messages.append(TestResultMessage(title, c))

    def add_long_text(self, title: str, content: str, with_line_numbers: bool = True):
        self.messages.append(TestResultMessage(title, content, multiline=True, with_line_numbers=with_line_numbers))

    def add_short_text(self, title, content: str):
        self.messages.append(TestResultMessage(title, content, multiline=False, with_line_numbers=False))

    def add_file(self, title: str, file_name: str, with_line_numbers: bool = True):
        with open(file_name, "r") as f:
            file_content = os.linesep.join([line.rstrip() for line in f])
        self.add_long_text(title, file_content, with_line_numbers)

    def succeeded(self):
        return self.has_succeeded

    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():
350
            return self.correct_msg
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
        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\""
            return self.incorrect_msg

    def long_message(self) -> str:
        texts = [self.short_message().capitalize()]
        if self.error_code is not None:
            texts.append("Error code: {}".format(self.error_code))
        for msg in self.messages:
            if msg.multiline:
                texts.append(msg.title + ":")
                texts.append("")
                if msg.with_line_numbers:
                    texts.append(self._ident(msg.content))
                else:
                    texts.append(msg.content)
Johannes Bechberger's avatar
Johannes Bechberger committed
368
                texts.append("")
369 370
            else:
                texts.append("{}: {}".format(msg.title, msg.content))
371
        return "\n".join(texts)
372 373 374 375 376 377 378 379 380 381 382 383

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

    def add_diff(self, title: str, first: str, second: str, with_line_numbers: bool):
        self.add_long_text(title, "".join(difflib.Differ().compare(first.splitlines(True), second.splitlines(True))),
                           with_line_numbers=with_line_numbers)

384 385 386
    def set_error_code(self, error_code: int):
        self.has_succeeded = error_code == 0
        self.error_code = error_code
387

388

389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
class TestResultMessage:

    def __init__(self, title: str, content: str, multiline: bool, with_line_numbers: bool):
        self.title = title
        self.content = content
        self.multiline = multiline
        self.with_line_numbers = with_line_numbers


class TestResultFactory:
    def __init__(self):
        self._texts = []  # type: [str, str, bool]
        self.return_code = 0
        self.short_error_message = None  # type: str

    def add_short_texts(self, title: str, content: str):
        self._texts.append((title, content, True))

    def add_long_message(self, title: str, content: str):
        self._texts.append((title, content, True))


Johannes Bechberger's avatar
Johannes Bechberger committed
411 412
class BasicTestResult(TestResult):

Johannes Bechberger's avatar
Johannes Bechberger committed
413 414
    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
415
        super().__init__(test_case, error_code)
Johannes Bechberger's avatar
Johannes Bechberger committed
416
        self._incorrect_msg = incorrect_msg
417
        self._contains_error_str = error_output is not None and "error" in error_output
Johannes Bechberger's avatar
Johannes Bechberger committed
418 419
        self.error_output = error_output
        self.output = output
420
        self.other_texts = [] # type: List[Tuple[str, str, bool]]
Johannes Bechberger's avatar
Johannes Bechberger committed
421 422 423 424
        if output:
            self.add_additional_text("Output", output)
        if error_output:
            self.add_additional_text("Error output", error_output)
425 426 427 428
        self.has_succeeded = error_code == 0

    def succeeded(self):
        return self.has_succeeded
Johannes Bechberger's avatar
Johannes Bechberger committed
429 430 431 432 433 434 435 436 437 438 439 440 441

    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
442
            return self._incorrect_msg
Johannes Bechberger's avatar
Johannes Bechberger committed
443 444

    def long_message(self) -> str:
445
        file_content = []
446
        with open(self.test_case.preprocessed_file, "r") as f:
447
            file_content = [line.rstrip() for line in f]
448 449 450 451 452 453 454 455 456 457 458
        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
459 460 461 462 463 464 465
        return """{}

Source file:

{}

Return code: {}
466 467

{}
Johannes Bechberger's avatar
Johannes Bechberger committed
468
""".format(self.short_message().capitalize(), self._ident(file_content), self.error_code,
469 470 471 472 473 474 475
           "\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
476 477 478

    def _ident(self, text: Union[str,List[str]]) -> str:
        arr = text if isinstance(text, list) else text.split("\n")
479 480 481 482
        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
483

Johannes Bechberger's avatar
Johannes Bechberger committed
484 485 486

class BasicDiffTestResult(BasicTestResult):

487 488
    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
489 490
        super().__init__(test_case, error_code, output, error_output)
        self.expected_output = expected_output
491
        self._is_output_correct = self.expected_output.strip() == self.output.strip()
Johannes Bechberger's avatar
Johannes Bechberger committed
492 493 494 495 496
        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)
497
        self.short_error_message = short_error_message
498
            #self.add_additional_text("Actual output", self.output)
Johannes Bechberger's avatar
Johannes Bechberger committed
499 500 501 502 503 504 505 506

    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:
507
        return "".join(difflib.Differ().compare(self.expected_output.splitlines(True), self.output.splitlines(True)))
Johannes Bechberger's avatar
Johannes Bechberger committed
508 509 510 511 512 513 514 515

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

    def short_message(self) -> str:
        if self.is_correct():
            return "correct"
        else:
516 517
            if self.short_error_message:
                return self.short_error_message
Johannes Bechberger's avatar
Johannes Bechberger committed
518 519 520 521 522 523 524
            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
525 526 527 528 529 530
class DiffTest(TestCase):

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

531 532
    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
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561
        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
562 563

import mjtest.test.syntax_tests
564
import mjtest.test.ast_tests
Johannes Bechberger's avatar
Johannes Bechberger committed
565
import mjtest.test.semantic_tests
566 567
import mjtest.test.exec_tests
import mjtest.test.bench