ej-test-gen 0.4.1__tar.gz

ej_test_gen-0.4.1/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Sergey Shashkov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ej_test_gen-0.4.1/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: ej_test_gen
+Version: 0.4.1
+Summary: Create tests for ejudge and co
+Author-email: Sergey Shashkov <sh57@yandex.ru>
+License: MIT
+Project-URL: Homepage, https://github.com/ShashkovS/ej_test_gen
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Create tests for ejudge using solution
+
+## Install
+```bash
+pip install git+https://github.com/ShashkovS/ej_test_gen.git --user --upgrade
+```
+
+## Example:
+
+```python
+# sol.py
+n = int(input())
+fct = 1
+for i in range(2, n + 1):
+    fct *= i
+print(fct)
+```
+
+```python
+# test_creator.py
+from ej_test_gen import TestRunner, random
+runner = TestRunner(solution="sol.py", tests_dir="tests")
+# runner = TestRunner(solution="sol.cpp", tests_dir="tests", use_WSL=True)
+
+runner.test("""3""")
+runner.test("""5""")
+
+for tests_in_group, group_max in [(2, 10), (5, 50)]:
+    for __ in range(tests_in_group):
+        n = random.randint(0, group_max)
+        test = f'{n}'
+        runner.test(test)
+```
+
+
+```bash
+> python test_creator.py
+001: 3         -->    6¶                                           Done! 0.27c
+002: 2         -->    2¶                                           Done! 0.25c
+003: 3         -->    6¶                                           Done! 0.26c
+004: 31        -->    8222838654177922817725562880000000¶          Done! 0.25c
+005: 10        -->    3628800¶                                     Done! 0.26c
+006: 15        -->    1307674368000¶                               Done! 0.26c
+007: 41        -->    3345252661316380710817006205344075166515     Done! 0.27c
+008: 15        -->    1307674368000¶                               Done! 0.27c
+```
+
+`TestRunner` resolves relative `solution` and `tests_dir` paths from the
+directory of the script where `TestRunner` is created. This means `sol.py` and
+`test_creator.py` can live in the same directory, and generated tests will be
+written to `tests/` next to them even if you run the script from another
+directory:
+
+```bash
+python path/to/test_creator.py
+```
+
+Pass `working_dir` explicitly when you want a different base directory. For
+example, `working_dir="."` keeps the old behavior where relative paths are
+resolved from the process current working directory.
+
+## Solution errors
+
+Use `on_error` to choose what happens when the solution exits with a non-zero
+return code or writes to stderr:
+
+```python
+# default: stop generation and raise RuntimeError
+runner = TestRunner(solution="sol.py", tests_dir="tests")
+
+# ignore: skip failed tests and keep generating the next ones
+runner = TestRunner(solution="sol.py", tests_dir="tests", on_error="ignore")
+
+# output: write stderr/traceback to the answer file
+runner = TestRunner(solution="sol.py", tests_dir="tests", on_error="output")
+```
+
+Old names are still accepted for compatibility: `on_error="raise"` means
+`on_error="default"`, and `on_error="skip"` means `on_error="ignore"`.
+
+
+# License
+
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means.

ej_test_gen-0.4.1/README.md

@@ -0,0 +1,86 @@
+# Create tests for ejudge using solution
+
+## Install
+```bash
+pip install git+https://github.com/ShashkovS/ej_test_gen.git --user --upgrade
+```
+
+## Example:
+
+```python
+# sol.py
+n = int(input())
+fct = 1
+for i in range(2, n + 1):
+    fct *= i
+print(fct)
+```
+
+```python
+# test_creator.py
+from ej_test_gen import TestRunner, random
+runner = TestRunner(solution="sol.py", tests_dir="tests")
+# runner = TestRunner(solution="sol.cpp", tests_dir="tests", use_WSL=True)
+
+runner.test("""3""")
+runner.test("""5""")
+
+for tests_in_group, group_max in [(2, 10), (5, 50)]:
+    for __ in range(tests_in_group):
+        n = random.randint(0, group_max)
+        test = f'{n}'
+        runner.test(test)
+```
+
+
+```bash
+> python test_creator.py
+001: 3         -->    6¶                                           Done! 0.27c
+002: 2         -->    2¶                                           Done! 0.25c
+003: 3         -->    6¶                                           Done! 0.26c
+004: 31        -->    8222838654177922817725562880000000¶          Done! 0.25c
+005: 10        -->    3628800¶                                     Done! 0.26c
+006: 15        -->    1307674368000¶                               Done! 0.26c
+007: 41        -->    3345252661316380710817006205344075166515     Done! 0.27c
+008: 15        -->    1307674368000¶                               Done! 0.27c
+```
+
+`TestRunner` resolves relative `solution` and `tests_dir` paths from the
+directory of the script where `TestRunner` is created. This means `sol.py` and
+`test_creator.py` can live in the same directory, and generated tests will be
+written to `tests/` next to them even if you run the script from another
+directory:
+
+```bash
+python path/to/test_creator.py
+```
+
+Pass `working_dir` explicitly when you want a different base directory. For
+example, `working_dir="."` keeps the old behavior where relative paths are
+resolved from the process current working directory.
+
+## Solution errors
+
+Use `on_error` to choose what happens when the solution exits with a non-zero
+return code or writes to stderr:
+
+```python
+# default: stop generation and raise RuntimeError
+runner = TestRunner(solution="sol.py", tests_dir="tests")
+
+# ignore: skip failed tests and keep generating the next ones
+runner = TestRunner(solution="sol.py", tests_dir="tests", on_error="ignore")
+
+# output: write stderr/traceback to the answer file
+runner = TestRunner(solution="sol.py", tests_dir="tests", on_error="output")
+```
+
+Old names are still accepted for compatibility: `on_error="raise"` means
+`on_error="default"`, and `on_error="skip"` means `on_error="ignore"`.
+
+
+# License
+
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means.

ej_test_gen-0.4.1/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ej_test_gen"
+version = "0.4.1"  # Версию нужно будет поддерживать вручную
+description = "Create tests for ejudge and co"
+readme = "README.md"
+authors = [
+    {name = "Sergey Shashkov", email = "sh57@yandex.ru"}
+]
+license = {text = "MIT"}
+requires-python = ">=3.8"
+
+dependencies = [
+]
+
+[project.urls]
+"Homepage" = "https://github.com/ShashkovS/ej_test_gen"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+include-package-data = true  # Включает все указанные данные в пакет
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*" = ["*.txt", "*.rst", "*.in", "*.png"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.5",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[project.scripts]
+# Здесь можно добавить консольные команды, если нужно
+# пример: "command_name" = "module:function"

ej_test_gen-0.4.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ej_test_gen-0.4.1/src/ej_test_gen/__about__.py

@@ -0,0 +1,11 @@
+__all__ = [
+    "__version__",
+    "__license__",
+    "__author__",
+    "__copyright__",
+]
+
+__version__ = '0.4.1'
+__author__ = "Sergey Shashkov"
+__license__ = "MIT"
+__copyright__ = "Copyright 2019- Sergey Shashkov"

ej_test_gen-0.4.1/src/ej_test_gen/__init__.py

@@ -0,0 +1,51 @@
+"""
+# ejudge test generator
+
+# Example1:
+from ej_test_gen import TestRunner, random
+runner = TestRunner(solution="sol.py", tests_dir="tests")
+runner.test("3")
+
+# sol.py
+n = int(input())
+fct = 1
+for i in range(2, n + 1):
+    fct *= i
+print(fct)
+
+# Example2:
+runner2 = TestRunner(
+        solution='sol.py',
+        tests_dir='tests',
+
+        test_name_template='{:02}',
+        test_is_binary=False,
+        test_encoding="utf-8",
+
+        ans_name_template='{:02}.a',
+        ans_encoding="utf-8",
+        ans_is_binary=False,
+
+        py_executable=sys.executable,
+        cpp_compiler="g++",
+        timeout=5,
+        use_WSL=False,
+        compilation_timeout=30,
+
+        # 'default': raise RuntimeError when solution fails
+        # 'ignore': skip failed tests
+        # 'output': save stderr/traceback as the answer
+        on_error='default',
+)
+
+# By default, relative solution and tests_dir paths are resolved from the
+# directory of the script creating TestRunner. Pass working_dir explicitly
+# when you want another base directory; working_dir='.' resolves paths from
+# the process current working directory.
+#
+# Old on_error aliases are still accepted:
+# 'raise' -> 'default', 'skip' -> 'ignore'.
+"""
+
+from .__about__ import *
+from .ej_test_gen import *

ej_test_gen-0.4.1/src/ej_test_gen/ej_test_gen.py

@@ -0,0 +1,353 @@
+# -*- coding: utf-8 -*-.
+import inspect
+import subprocess
+import os
+import time
+import sys
+import logging
+import random
+import platform
+
+random.seed(2000)
+logging.basicConfig(level=logging.INFO)
+lg = logging.getLogger('Runner')
+
+__all__ = ['TestRunner', 'random']
+
+_is_windows = platform.system() == 'Windows'
+_ON_ERROR_ALIASES = {
+    'default': 'default',
+    'raise': 'default',
+    'ignore': 'ignore',
+    'skip': 'ignore',
+    'output': 'output',
+}
+
+class TestRunner:
+    __test__ = False
+
+    solution: str
+    working_dir: str
+    tests_dir: str
+
+    test_name_template: str
+    test_is_binary: bool
+    test_encoding: str
+
+    ans_name_template: str
+    ans_encoding: str
+    ans_is_binary: bool
+
+    py_executable: str
+    cpp_compiler: str
+    timeout: int
+    use_WSL: bool
+    compilation_timeout: int
+
+    on_error: str  # 'default' | 'ignore' | 'output'
+
+    def __init__(
+        self,
+        solution='sol.py',
+        working_dir=None,
+        tests_dir='.',
+
+        test_name_template='{:02}',
+        test_is_binary=False,
+        test_encoding="utf-8",
+
+        ans_name_template='{:02}.a',
+        ans_encoding="utf-8",
+        ans_is_binary=False,
+
+        py_executable=sys.executable,
+        cpp_compiler="g++",
+        timeout=5,
+        use_WSL=False,
+        compilation_timeout=30,
+
+        on_error='default',
+    ):
+        self.__dict__.update({k: v for k, v in locals().items() if k != 'self'})
+
+        self.solution = os.fspath(self.solution)
+        if self.tests_dir is not None:
+            self.tests_dir = os.fspath(self.tests_dir)
+        self.on_error = self._normalize_on_error(self.on_error)
+
+        # working_dir=None: default to the directory of the script creating TestRunner.
+        # Explicit relative working_dir values keep the old cwd-based behavior.
+        if self.working_dir is None:
+            self.working_dir = self._default_working_dir()
+        else:
+            self.working_dir = os.fspath(self.working_dir)
+        if not os.path.isabs(self.working_dir):
+            self.working_dir = os.path.normpath(os.path.join(os.getcwd(), self.working_dir))
+        # tests_dir: relative paths resolved from working_dir
+        if not os.path.isabs(self.tests_dir):
+            self.tests_dir = os.path.normpath(os.path.join(self.working_dir, self.tests_dir))
+
+        os.makedirs(self.tests_dir, exist_ok=True)
+        self.compile_sol()
+        self._clean_up()
+
+    @staticmethod
+    def _default_working_dir():
+        frame = inspect.currentframe()
+        try:
+            caller_frame = frame.f_back.f_back if frame and frame.f_back else None
+            filename = caller_frame.f_code.co_filename if caller_frame else None
+            if filename and not filename.startswith('<'):
+                return os.path.dirname(os.path.abspath(filename))
+            return os.getcwd()
+        finally:
+            del frame
+
+    @staticmethod
+    def _normalize_on_error(on_error):
+        try:
+            return _ON_ERROR_ALIASES[on_error]
+        except KeyError:
+            allowed = "', '".join(sorted(_ON_ERROR_ALIASES))
+            raise ValueError("on_error must be one of: '{}'".format(allowed))
+
+    def __repr__(self):
+        return (f'{self.__class__.__name__}('
+                f'  {self.solution=!r}, '
+                f'  {self.working_dir=!r}, '
+                f'  {self.tests_dir=!r}, '
+                f'  {self.test_name_template=!r}, '
+                f'  {self.test_is_binary=!r}, '
+                f'  {self.test_encoding=!r}, '
+                f'  {self.ans_name_template=!r}, '
+                f'  {self.ans_encoding=!r}, '
+                f'  {self.ans_is_binary=!r}, '
+                f'  {self.py_executable=!r}, '
+                f'  {self.cpp_compiler=!r}, '
+                f'  {self.timeout=!r}, '
+                f'  {self.use_WSL=!r}, '
+                f'  {self.on_error=!r}'
+                f')')
+
+    def _run(self, to_stdin):
+        if self.test_is_binary:
+            input_data = to_stdin
+        else:
+            input_data = bytes(to_stdin, encoding=self.test_encoding)
+        st = time.time()
+        if self._compiled:
+            to_run = [self._compiled if os.path.isabs(self._compiled) else './' + self._compiled]
+        else:  # TODO Вообще-то, это если питон
+            to_run = [self.py_executable, self.solution]
+        if self.use_WSL and _is_windows:
+            to_run = 'bash -c "{}"'.format(' '.join(to_run))
+        elif _is_windows:
+            to_run = ' '.join(to_run)
+        lg.debug(to_run)
+        pr = subprocess.Popen(
+            to_run,
+            stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE,
+            cwd=self.working_dir
+        )
+        stdout_bytes, stderr_bytes = pr.communicate(input=input_data, timeout=self.timeout)
+        dur = time.time() - st
+        if self.ans_is_binary:
+            from_stdout = stdout_bytes
+        else:
+            from_stdout = stdout_bytes.decode(self.ans_encoding, errors="ignore")
+            from_stdout = from_stdout.replace('\r\n', '\n').replace('\r', '\n')
+            trash_pos = from_stdout.find('pydev debugger:')
+            if trash_pos >= 0:
+                from_stdout = from_stdout[:trash_pos]
+        return from_stdout, stderr_bytes, pr.returncode, dur
+
+    def _clean_up(self):
+        # Удаляем старые тесты
+        for filename in os.listdir(self.tests_dir):
+            testname = filename
+            if testname.endswith('.a'):
+                testname = testname[:-2]
+            if testname.isdigit():
+                os.remove(os.path.join(self.tests_dir, filename))
+
+    @staticmethod
+    def _list_test_files(path):
+        """Find all files in given path which names contains only decimal digits.
+        Such files are considered as test files.
+        Result is sorted by int(test_name)"""
+        test_files = [tname for tname in os.listdir(path)
+                      if tname.isdecimal() and os.path.isfile(os.path.join(path, tname))]
+        test_files.sort(key=lambda x: int(x))
+        return test_files
+
+    @staticmethod
+    def _prc_text_for_console(text, is_binary=False, max_len=40):
+        if is_binary:
+            show_text = str(text[:max_len])[:max_len]
+        else:
+            show_text = text[:max_len]
+        return show_text.replace('\r\n', '¶').replace('\n', '¶').replace('\r', '¶')
+
+    @staticmethod
+    def _cmp_two_outputs(output1, output2):
+        eq = output1.rstrip() == output2.rstrip()
+        return eq, ''
+
+    @staticmethod
+    def _read_test_or_ans(file_full_path, is_binary, encoding):
+        open_parms = dict(file=file_full_path, mode='r')
+        if is_binary:
+            open_parms['mode'] = 'rb'
+        else:
+            open_parms['encoding'] = encoding
+            open_parms['errors'] = "ignore"
+        with open(**open_parms) as f:
+            test_data = f.read()
+        return test_data
+
+    def _stderr_as_answer(self, stderr_bytes, returncode):
+        if stderr_bytes:
+            if self.ans_is_binary:
+                return stderr_bytes
+            return stderr_bytes.decode(self.ans_encoding, errors='replace').replace('\r\n', '\n').replace('\r', '\n')
+        fallback = 'Solution exited with returncode={}\n'.format(returncode)
+        if self.ans_is_binary:
+            return fallback.encode(self.ans_encoding, errors='replace')
+        return fallback
+
+    def _run_given_tests(self, test_files):
+        for tname in test_files:
+            lg.info('Processing test ' + tname + '...')
+
+            # First we read the test
+            try:
+                test_data = self._read_test_or_ans(
+                    os.path.join(self.tests_dir, tname), self.test_is_binary, self.test_encoding
+                )
+            except Exception as e:
+                lg.error('Error while reading test ' + tname + ': ' + str(e))
+                continue
+            # Then we read the result
+            tname += self.ans_suffix
+            try:
+                ans_data = self._read_test_or_ans(
+                    os.path.join(self.tests_dir, tname), self.ans_is_binary, self.ans_encoding
+                )
+            except Exception as e:
+                lg.error('Error while reading test result for ' + tname + ': ' + str(e))
+                continue
+
+            # Ok, now we are ready to run pgm
+            try:
+                from_stdout, stderr_bytes, returncode, dur = self._run(to_stdin=test_data)
+            except Exception as e:
+                lg.error('Error while running test ' + tname + ': ' + str(e))
+                continue
+
+            show_test = self._prc_text_for_console(test_data, self.test_is_binary)
+            show_res = self._prc_text_for_console(from_stdout, self.ans_is_binary)
+            show_ans = self._prc_text_for_console(ans_data, self.ans_is_binary)
+
+            eq, description = self._cmp_two_outputs(ans_data, from_stdout)
+            msg = 'Test {}, {}. Dur:{:0.2f}.  {} -> {}  (Corr: {})'.format(
+                tname, "OK" if eq else "WA", dur, show_test, show_res, show_ans
+            )
+            if eq:
+                lg.info(msg)
+            else:
+                lg.error(msg)
+
+    def compile_sol(self):
+        self._compiled = None
+        name, _, ext = self.solution.rpartition('.')
+        ext = ext.lower()
+        if ext == 'py':
+            return
+        elif ext == 'cpp':
+            self._compiled = '{}.exe'.format(name) if _is_windows else name
+            compiled_path = self._compiled
+            if not os.path.isabs(compiled_path):
+                compiled_path = os.path.join(self.working_dir, compiled_path)
+            if os.path.isfile(compiled_path):
+                os.remove(compiled_path)
+            cmd = [self.cpp_compiler, self.solution, '-o', self._compiled]
+            if self.use_WSL and _is_windows:
+                cmd = 'bash -c "{}"'.format(' '.join(cmd))
+            elif _is_windows:
+                cmd = ' '.join(cmd)
+
+            lg.debug(cmd)
+            pr = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                cwd=self.working_dir
+            )
+            stdout, stderr = pr.communicate(timeout=self.compilation_timeout)
+            lg.debug('stdout={}\nstderr={}'.format(stdout, stderr))
+            if stderr:
+                raise EnvironmentError(stderr.decode('utf-8', 'ignore'))
+
+    def run_test(self):
+        test_files = self._list_test_files(self.tests_dir)
+        self._run_given_tests(test_files)
+
+    def test(self, test, *, _test_num=[0], _max_len=40):
+        test = test.strip()
+        if not self.test_is_binary:
+            test += '\n'
+        text_prt = self._prc_text_for_console(test, self.test_is_binary)
+        _test_num[0] += 1
+        _test_num_str = self.test_name_template.format(_test_num[0])
+        _ans_num_str = self.ans_name_template.format(_test_num[0])
+        print(
+            '{}: {}{}    -->    '.format(
+                _test_num_str, text_prt[:_max_len].ljust(_max_len),
+                '...' if text_prt[_max_len:] else '   '
+            ), end=''
+        )
+
+        ans, stderr_bytes, returncode, dur = self._run(test)
+        if not self.ans_is_binary and not ans.endswith('\n'):
+            ans += '\n'
+
+        failed = returncode != 0 or bool(stderr_bytes)
+        if failed:
+            stderr_preview = stderr_bytes.decode('utf-8', errors='replace')[:200] if stderr_bytes else ''
+            if self.on_error == 'default':
+                print('ERROR (returncode={})'.format(returncode))
+                raise RuntimeError(
+                    'Test {}: solution exited with returncode={}, stderr={!r}'.format(
+                        _test_num_str, returncode, stderr_preview
+                    )
+                )
+            elif self.on_error == 'ignore':
+                print('skipped (returncode={}{})'.format(
+                    returncode,
+                    ', stderr: ' + stderr_preview if stderr_preview else ''
+                ))
+                _test_num[0] -= 1
+                return
+            else:  # 'output'
+                ans = self._stderr_as_answer(stderr_bytes, returncode)
+
+        ans_prt = self._prc_text_for_console(ans, self.ans_is_binary)
+        if dur <= self.timeout:
+            print(
+                '{}{}  Done! {:.2}c'.format(
+                    ans_prt[:_max_len].ljust(_max_len),
+                    '...' if ans_prt[_max_len:] else '   ', dur
+                )
+            )
+
+            with open(os.path.join(self.tests_dir, _test_num_str), 'w' + ('b' if self.test_is_binary else '')) as f:
+                f.write(test)
+            with open(os.path.join(self.tests_dir, _ans_num_str), 'w' + ('b' if self.ans_is_binary else '')) as f:
+                f.write(ans)
+        else:
+            print('timeout', '{:.2}c'.format(dur))
+
+
+if __name__ == '__main__':
+    # runner = TestRunner()
+    # runner.run_test()
+    print('sudo rm -rf, are you sure? Ok, type "password".')

ej_test_gen-0.4.1/src/ej_test_gen.egg-info/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: ej_test_gen
+Version: 0.4.1
+Summary: Create tests for ejudge and co
+Author-email: Sergey Shashkov <sh57@yandex.ru>
+License: MIT
+Project-URL: Homepage, https://github.com/ShashkovS/ej_test_gen
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Create tests for ejudge using solution
+
+## Install
+```bash
+pip install git+https://github.com/ShashkovS/ej_test_gen.git --user --upgrade
+```
+
+## Example:
+
+```python
+# sol.py
+n = int(input())
+fct = 1
+for i in range(2, n + 1):
+    fct *= i
+print(fct)
+```
+
+```python
+# test_creator.py
+from ej_test_gen import TestRunner, random
+runner = TestRunner(solution="sol.py", tests_dir="tests")
+# runner = TestRunner(solution="sol.cpp", tests_dir="tests", use_WSL=True)
+
+runner.test("""3""")
+runner.test("""5""")
+
+for tests_in_group, group_max in [(2, 10), (5, 50)]:
+    for __ in range(tests_in_group):
+        n = random.randint(0, group_max)
+        test = f'{n}'
+        runner.test(test)
+```
+
+
+```bash
+> python test_creator.py
+001: 3         -->    6¶                                           Done! 0.27c
+002: 2         -->    2¶                                           Done! 0.25c
+003: 3         -->    6¶                                           Done! 0.26c
+004: 31        -->    8222838654177922817725562880000000¶          Done! 0.25c
+005: 10        -->    3628800¶                                     Done! 0.26c
+006: 15        -->    1307674368000¶                               Done! 0.26c
+007: 41        -->    3345252661316380710817006205344075166515     Done! 0.27c
+008: 15        -->    1307674368000¶                               Done! 0.27c
+```
+
+`TestRunner` resolves relative `solution` and `tests_dir` paths from the
+directory of the script where `TestRunner` is created. This means `sol.py` and
+`test_creator.py` can live in the same directory, and generated tests will be
+written to `tests/` next to them even if you run the script from another
+directory:
+
+```bash
+python path/to/test_creator.py
+```
+
+Pass `working_dir` explicitly when you want a different base directory. For
+example, `working_dir="."` keeps the old behavior where relative paths are
+resolved from the process current working directory.
+
+## Solution errors
+
+Use `on_error` to choose what happens when the solution exits with a non-zero
+return code or writes to stderr:
+
+```python
+# default: stop generation and raise RuntimeError
+runner = TestRunner(solution="sol.py", tests_dir="tests")
+
+# ignore: skip failed tests and keep generating the next ones
+runner = TestRunner(solution="sol.py", tests_dir="tests", on_error="ignore")
+
+# output: write stderr/traceback to the answer file
+runner = TestRunner(solution="sol.py", tests_dir="tests", on_error="output")
+```
+
+Old names are still accepted for compatibility: `on_error="raise"` means
+`on_error="default"`, and `on_error="skip"` means `on_error="ignore"`.
+
+
+# License
+
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means.

ej_test_gen-0.4.1/src/ej_test_gen.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/ej_test_gen/__about__.py
+src/ej_test_gen/__init__.py
+src/ej_test_gen/ej_test_gen.py
+src/ej_test_gen.egg-info/PKG-INFO
+src/ej_test_gen.egg-info/SOURCES.txt
+src/ej_test_gen.egg-info/dependency_links.txt
+src/ej_test_gen.egg-info/top_level.txt
+tests/test_runner.py

ej_test_gen-0.4.1/src/ej_test_gen.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ej_test_gen-0.4.1/src/ej_test_gen.egg-info/top_level.txt

@@ -0,0 +1 @@
+ej_test_gen

ej_test_gen-0.4.1/tests/test_runner.py

@@ -0,0 +1,579 @@
+import os
+import platform
+import sqlite3
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent / 'src'))
+from ej_test_gen import TestRunner
+
+
+def write_solution(tmp_path, code):
+    sol = tmp_path / 'sol.py'
+    sol.write_text(code, encoding='utf-8')
+    return str(sol)
+
+
+def get_input_files(tmp_path):
+    """Return sorted list of test input files (names are all digits)."""
+    files = [f for f in tmp_path.iterdir() if f.name.isdecimal()]
+    return sorted(files, key=lambda f: int(f.name))
+
+
+def get_answer_file(input_file):
+    return input_file.parent / (input_file.name + '.a')
+
+
+# ---------------------------------------------------------------------------
+# Text input / text output
+# ---------------------------------------------------------------------------
+
+class TestTextIO:
+    def test_echo(self, tmp_path):
+        sol = write_solution(tmp_path, "print(input())")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path))
+        runner.test('hello')
+
+        inputs = get_input_files(tmp_path)
+        assert len(inputs) == 1
+        assert inputs[0].read_text(encoding='utf-8') == 'hello\n'
+        assert get_answer_file(inputs[0]).read_text(encoding='utf-8').strip() == 'hello'
+
+    def test_text_files_have_final_newline(self, tmp_path):
+        sol = write_solution(tmp_path, "import sys; sys.stdout.write(input())")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path))
+        runner.test('hello\n\n')
+
+        input_file = get_input_files(tmp_path)[0]
+        assert input_file.read_bytes() == b'hello\n'
+        assert get_answer_file(input_file).read_bytes() == b'hello\n'
+
+    def test_arithmetic(self, tmp_path):
+        sol = write_solution(tmp_path, "a, b = map(int, input().split()); print(a + b)")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path))
+        runner.test('3 4')
+
+        inputs = get_input_files(tmp_path)
+        assert get_answer_file(inputs[0]).read_text(encoding='utf-8').strip() == '7'
+
+    def test_multiple_tests(self, tmp_path):
+        sol = write_solution(tmp_path, "print(int(input()) * 2)")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path))
+        runner.test('3')
+        runner.test('5')
+
+        inputs = get_input_files(tmp_path)
+        assert len(inputs) == 2
+        answers = [get_answer_file(f).read_text().strip() for f in inputs]
+        assert answers == ['6', '10']
+
+
+# ---------------------------------------------------------------------------
+# Binary input / text output
+# ---------------------------------------------------------------------------
+
+class TestBinaryInput:
+    def test_binary_stdin_byte_count(self, tmp_path):
+        """Binary input (arbitrary bytes) → text output: length of data."""
+        code = "import sys; data = sys.stdin.buffer.read(); print(len(data))"
+        sol = write_solution(tmp_path, code)
+        binary_data = bytes(range(256))
+
+        runner = TestRunner(
+            solution=sol,
+            working_dir=str(tmp_path),
+            test_is_binary=True,
+            ans_is_binary=False,
+        )
+        runner.test(binary_data)
+
+        inputs = get_input_files(tmp_path)
+        assert inputs[0].read_bytes() == binary_data
+        assert get_answer_file(inputs[0]).read_text().strip() == '256'
+
+    def test_binary_stdin_null_bytes(self, tmp_path):
+        """Binary input containing null bytes (common in binary files)."""
+        code = "import sys; d = sys.stdin.buffer.read(); print(d.count(0))"
+        sol = write_solution(tmp_path, code)
+        binary_data = bytes([0x00, 0x01, 0x00, 0xFF, 0x00])  # three null bytes
+
+        runner = TestRunner(
+            solution=sol,
+            working_dir=str(tmp_path),
+            test_is_binary=True,
+            ans_is_binary=False,
+        )
+        runner.test(binary_data)
+
+        inputs = get_input_files(tmp_path)
+        assert inputs[0].read_bytes() == binary_data
+        assert get_answer_file(inputs[0]).read_text().strip() == '3'
+
+    def test_sqlite_database_input(self, tmp_path):
+        """Binary input is a SQLite database file."""
+        # Build a tiny DB
+        db_path = tmp_path / 'input.db'
+        conn = sqlite3.connect(str(db_path))
+        conn.execute('CREATE TABLE nums (val INTEGER)')
+        conn.execute('INSERT INTO nums VALUES (42)')
+        conn.commit()
+        conn.close()
+        db_bytes = db_path.read_bytes()
+
+        code = '''
+import sys, sqlite3, tempfile, os
+data = sys.stdin.buffer.read()
+with tempfile.NamedTemporaryFile(suffix='.db', delete=False) as f:
+    f.write(data)
+    fname = f.name
+conn = sqlite3.connect(fname)
+row = conn.execute('SELECT val FROM nums').fetchone()
+conn.close()
+os.unlink(fname)
+print(row[0])
+'''
+        sol = write_solution(tmp_path, code)
+        runner = TestRunner(
+            solution=sol,
+            working_dir=str(tmp_path),
+            test_is_binary=True,
+            ans_is_binary=False,
+        )
+        runner.test(db_bytes)
+
+        inputs = get_input_files(tmp_path)
+        assert inputs[0].read_bytes() == db_bytes
+        assert get_answer_file(inputs[0]).read_text().strip() == '42'
+
+
+# ---------------------------------------------------------------------------
+# Text input / binary output
+# ---------------------------------------------------------------------------
+
+class TestBinaryOutput:
+    def test_text_in_binary_out(self, tmp_path):
+        """Text input → binary output: emit n sequential bytes."""
+        code = "import sys; n = int(input()); sys.stdout.buffer.write(bytes(range(n)))"
+        sol = write_solution(tmp_path, code)
+
+        runner = TestRunner(
+            solution=sol,
+            working_dir=str(tmp_path),
+            test_is_binary=False,
+            ans_is_binary=True,
+        )
+        runner.test('5')
+
+        inputs = get_input_files(tmp_path)
+        assert inputs[0].read_text().strip() == '5'
+        assert get_answer_file(inputs[0]).read_bytes() == bytes(range(5))
+
+    def test_text_in_binary_out_with_nulls(self, tmp_path):
+        """Binary output must preserve null bytes."""
+        code = "import sys; sys.stdout.buffer.write(bytes([0, 1, 0, 2, 0]))"
+        sol = write_solution(tmp_path, code)
+
+        runner = TestRunner(
+            solution=sol,
+            working_dir=str(tmp_path),
+            test_is_binary=False,
+            ans_is_binary=True,
+        )
+        runner.test('ignored')
+
+        inputs = get_input_files(tmp_path)
+        assert get_answer_file(inputs[0]).read_bytes() == bytes([0, 1, 0, 2, 0])
+
+
+# ---------------------------------------------------------------------------
+# Binary input / binary output
+# ---------------------------------------------------------------------------
+
+class TestBinaryInputOutput:
+    def test_invert_bytes(self, tmp_path):
+        """Binary in/out: bitwise invert every byte."""
+        code = "import sys; d = sys.stdin.buffer.read(); sys.stdout.buffer.write(bytes(b ^ 0xFF for b in d))"
+        sol = write_solution(tmp_path, code)
+
+        input_bytes = bytes([0x00, 0xFF, 0xAA, 0x55])
+        expected = bytes([0xFF, 0x00, 0x55, 0xAA])
+
+        runner = TestRunner(
+            solution=sol,
+            working_dir=str(tmp_path),
+            test_is_binary=True,
+            ans_is_binary=True,
+        )
+        runner.test(input_bytes)
+
+        inputs = get_input_files(tmp_path)
+        assert inputs[0].read_bytes() == input_bytes
+        assert get_answer_file(inputs[0]).read_bytes() == expected
+
+    def test_image_like_binary(self, tmp_path):
+        """Binary in/out: strip first 8 bytes (simulate PNG header extraction)."""
+        png_header = bytes([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A])
+        input_bytes = png_header + bytes(range(100))
+
+        code = "import sys; d = sys.stdin.buffer.read(); sys.stdout.buffer.write(d[:8])"
+        sol = write_solution(tmp_path, code)
+
+        runner = TestRunner(
+            solution=sol,
+            working_dir=str(tmp_path),
+            test_is_binary=True,
+            ans_is_binary=True,
+        )
+        runner.test(input_bytes)
+
+        inputs = get_input_files(tmp_path)
+        assert inputs[0].read_bytes() == input_bytes
+        assert get_answer_file(inputs[0]).read_bytes() == png_header
+
+    def test_binary_passthrough_large(self, tmp_path):
+        """Binary in/out: 1 KB of non-whitespace bytes are faithfully preserved."""
+        # Avoid trailing whitespace bytes (0x00–0x08, 0x0e–0x1f, 0x21–0xff are safe)
+        input_bytes = bytes([((i * 7 + 33) % 223) + 33 for i in range(1024)])
+        code = "import sys; sys.stdout.buffer.write(sys.stdin.buffer.read())"
+        sol = write_solution(tmp_path, code)
+        runner = TestRunner(
+            solution=sol,
+            working_dir=str(tmp_path),
+            test_is_binary=True,
+            ans_is_binary=True,
+        )
+        runner.test(input_bytes)
+
+        inputs = get_input_files(tmp_path)
+        assert inputs[0].read_bytes() == input_bytes
+        assert get_answer_file(inputs[0]).read_bytes() == input_bytes
+
+
+# ---------------------------------------------------------------------------
+# use_WSL=True ignored on non-Windows
+# ---------------------------------------------------------------------------
+
+# ---------------------------------------------------------------------------
+# tests_dir
+# ---------------------------------------------------------------------------
+
+class TestTestsDir:
+    def test_default_tests_dir_equals_working_dir(self, tmp_path):
+        """Default tests_dir='.' stores files directly in working_dir."""
+        sol = write_solution(tmp_path, "print(int(input()) + 1)")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path))
+        runner.test('9')
+
+        inputs = get_input_files(tmp_path)
+        assert len(inputs) == 1
+        assert get_answer_file(inputs[0]).read_text().strip() == '10'
+
+    def test_relative_tests_dir_created_automatically(self, tmp_path):
+        """Relative tests_dir is created under working_dir automatically."""
+        sol = write_solution(tmp_path, "print(int(input()) * 3)")
+        subdir = tmp_path / 'generated'
+        assert not subdir.exists()
+
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path), tests_dir='generated')
+        assert subdir.exists()
+
+        runner.test('7')
+        inputs = get_input_files(subdir)
+        assert len(inputs) == 1
+        assert get_answer_file(inputs[0]).read_text().strip() == '21'
+        # Root working_dir must stay clean of test files
+        assert get_input_files(tmp_path) == []
+
+    def test_nested_relative_tests_dir_created(self, tmp_path):
+        """Multi-level relative tests_dir is created with makedirs."""
+        sol = write_solution(tmp_path, "print('hi')")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path), tests_dir='a/b/c')
+        nested = tmp_path / 'a' / 'b' / 'c'
+        assert nested.exists()
+
+        runner.test('x')
+        assert len(get_input_files(nested)) == 1
+
+    def test_absolute_tests_dir(self, tmp_path):
+        """Absolute tests_dir path is used as-is regardless of working_dir."""
+        sol_dir = tmp_path / 'sol'
+        sol_dir.mkdir()
+        out_dir = tmp_path / 'out'
+        # out_dir does not exist yet
+
+        sol = write_solution(sol_dir, "print(42)")
+        runner = TestRunner(
+            solution=str(sol),
+            working_dir=str(sol_dir),
+            tests_dir=str(out_dir),  # absolute
+        )
+        assert out_dir.exists()
+
+        runner.test('ignored')
+        assert len(get_input_files(out_dir)) == 1
+        assert get_input_files(sol_dir) == []
+
+    def test_existing_tests_dir_ok(self, tmp_path):
+        """If tests_dir already exists, no error is raised."""
+        subdir = tmp_path / 'tests'
+        subdir.mkdir()
+        sol = write_solution(tmp_path, "print('x')")
+        # Should not raise even though the directory exists
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path), tests_dir='tests')
+        runner.test('y')
+        assert len(get_input_files(subdir)) == 1
+
+    def test_cleanup_only_affects_tests_dir(self, tmp_path):
+        """_clean_up removes old test files only from tests_dir, not working_dir root."""
+        sol = write_solution(tmp_path, "print('ok')")
+        subdir = tmp_path / 'tests'
+
+        # Pre-populate tests_dir with stale test files
+        subdir.mkdir()
+        (subdir / '01').write_text('old input')
+        (subdir / '01.a').write_text('old answer')
+
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path), tests_dir='tests')
+        # _clean_up is called in __init__; stale files should be gone
+        assert not (subdir / '01').exists()
+        assert not (subdir / '01.a').exists()
+
+
+# ---------------------------------------------------------------------------
+# working_dir resolution
+# ---------------------------------------------------------------------------
+
+class TestWorkingDir:
+    def test_default_working_dir_is_creator_script_dir(self, tmp_path):
+        """Without working_dir, resolve sol.py and tests_dir relative to gen.py."""
+        src_path = Path(__file__).parent.parent / 'src'
+        task_dir = tmp_path / 'task'
+        task_dir.mkdir()
+        (task_dir / 'sol.py').write_text("print(input())\n", encoding='utf-8')
+        (task_dir / 'gen.py').write_text(
+            "import sys\n"
+            f"sys.path.insert(0, {str(src_path)!r})\n"
+            "from ej_test_gen import TestRunner\n"
+            "runner = TestRunner(solution='sol.py', tests_dir='tests')\n"
+            "runner.test('hello')\n",
+            encoding='utf-8',
+        )
+
+        result = subprocess.run(
+            [sys.executable, str(task_dir / 'gen.py')],
+            cwd=str(tmp_path),
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+        assert result.returncode == 0, result.stderr
+        assert (task_dir / 'tests' / '01').read_text(encoding='utf-8') == 'hello\n'
+        assert (task_dir / 'tests' / '01.a').read_text(encoding='utf-8').strip() == 'hello'
+        assert not (tmp_path / 'tests').exists()
+
+    def test_explicit_relative_working_dir_uses_process_cwd(self, tmp_path):
+        """Explicit working_dir='.' keeps the old cwd-based behavior."""
+        src_path = Path(__file__).parent.parent / 'src'
+        cwd_dir = tmp_path / 'cwd'
+        task_dir = tmp_path / 'task'
+        cwd_dir.mkdir()
+        task_dir.mkdir()
+        (cwd_dir / 'sol.py').write_text("print(input()[::-1])\n", encoding='utf-8')
+        (task_dir / 'gen.py').write_text(
+            "import sys\n"
+            f"sys.path.insert(0, {str(src_path)!r})\n"
+            "from ej_test_gen import TestRunner\n"
+            "runner = TestRunner(solution='sol.py', working_dir='.', tests_dir='tests')\n"
+            "runner.test('abc')\n",
+            encoding='utf-8',
+        )
+
+        result = subprocess.run(
+            [sys.executable, str(task_dir / 'gen.py')],
+            cwd=str(cwd_dir),
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+        assert result.returncode == 0, result.stderr
+        assert (cwd_dir / 'tests' / '01').read_text(encoding='utf-8') == 'abc\n'
+        assert (cwd_dir / 'tests' / '01.a').read_text(encoding='utf-8').strip() == 'cba'
+        assert not (task_dir / 'tests').exists()
+
+    def test_constructor_does_not_change_process_cwd(self, tmp_path):
+        """TestRunner should use subprocess cwd without changing the caller's cwd."""
+        cwd_before = Path.cwd()
+        sol = write_solution(tmp_path, "print(input())")
+
+        TestRunner(solution=sol, working_dir=tmp_path)
+
+        assert Path.cwd() == cwd_before
+
+
+# ---------------------------------------------------------------------------
+# on_error behaviour
+# ---------------------------------------------------------------------------
+
+class TestOnError:
+    def test_default_on_nonzero_exit(self, tmp_path):
+        """on_error='default' raises RuntimeError on non-zero returncode."""
+        sol = write_solution(tmp_path, "raise ValueError('boom')")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path))
+
+        with pytest.raises(RuntimeError, match='returncode'):
+            runner.test('anything')
+
+    def test_default_on_stderr(self, tmp_path):
+        """on_error='default' raises RuntimeError when solution writes to stderr."""
+        code = "import sys; sys.stderr.write('oops\\n'); print('ok')"
+        sol = write_solution(tmp_path, code)
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path))
+
+        with pytest.raises(RuntimeError):
+            runner.test('anything')
+
+    def test_default_no_files_created(self, tmp_path):
+        """When on_error='default', no test files are written before the exception."""
+        sol = write_solution(tmp_path, "raise RuntimeError('x')")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path))
+
+        with pytest.raises(RuntimeError):
+            runner.test('x')
+
+        assert get_input_files(tmp_path) == []
+
+    def test_ignore_on_nonzero_exit(self, tmp_path):
+        """on_error='ignore' silently skips tests where solution crashes."""
+        sol = write_solution(tmp_path, "raise ValueError('boom')")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path), on_error='ignore')
+
+        # Must not raise
+        runner.test('anything')
+        assert get_input_files(tmp_path) == []
+
+    def test_ignore_does_not_advance_counter(self, tmp_path):
+        """Ignored tests don't consume a test number slot."""
+        code = """\
+import sys
+n = int(input())
+if n < 0:
+    raise ValueError('negative')
+print(n * 2)
+"""
+        sol = write_solution(tmp_path, code)
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path), on_error='ignore')
+
+        runner.test('3')   # succeeds → file '01' (or some N)
+        runner.test('-1')  # crashes  → skipped, counter not advanced
+        runner.test('5')   # succeeds → file 'N+1'
+
+        inputs = get_input_files(tmp_path)
+        assert len(inputs) == 2
+        answers = [get_answer_file(f).read_text().strip() for f in inputs]
+        assert answers == ['6', '10']
+        # The two files must be consecutive
+        nums = [int(f.name) for f in inputs]
+        assert nums[1] == nums[0] + 1
+
+    def test_ignore_on_stderr(self, tmp_path):
+        """on_error='ignore' skips tests that produce stderr output."""
+        code = "import sys; sys.stderr.write('warn\\n'); print('result')"
+        sol = write_solution(tmp_path, code)
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path), on_error='ignore')
+
+        runner.test('x')
+        assert get_input_files(tmp_path) == []
+
+    def test_output_uses_stderr_as_answer(self, tmp_path):
+        """on_error='output' writes traceback/stderr as the answer file."""
+        sol = write_solution(tmp_path, "raise ValueError('boom')")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path), on_error='output')
+
+        runner.test('anything')
+
+        inputs = get_input_files(tmp_path)
+        assert len(inputs) == 1
+        assert inputs[0].read_text(encoding='utf-8') == 'anything\n'
+        answer = get_answer_file(inputs[0]).read_text(encoding='utf-8')
+        assert 'Traceback' in answer
+        assert 'ValueError: boom' in answer
+
+    def test_output_without_stderr_uses_returncode_message(self, tmp_path):
+        """on_error='output' has deterministic output even without stderr."""
+        sol = write_solution(tmp_path, "import os; os._exit(7)")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path), on_error='output')
+
+        runner.test('anything')
+
+        inputs = get_input_files(tmp_path)
+        assert get_answer_file(inputs[0]).read_text(encoding='utf-8') == 'Solution exited with returncode=7\n'
+
+    def test_old_raise_alias_still_works(self, tmp_path):
+        """on_error='raise' remains an alias for on_error='default'."""
+        sol = write_solution(tmp_path, "raise ValueError('boom')")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path), on_error='raise')
+
+        with pytest.raises(RuntimeError, match='returncode'):
+            runner.test('anything')
+
+    def test_old_skip_alias_still_works(self, tmp_path):
+        """on_error='skip' remains an alias for on_error='ignore'."""
+        sol = write_solution(tmp_path, "raise ValueError('boom')")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path), on_error='skip')
+
+        runner.test('anything')
+        assert get_input_files(tmp_path) == []
+
+    def test_invalid_on_error(self, tmp_path):
+        """Unknown on_error values fail fast in TestRunner construction."""
+        sol = write_solution(tmp_path, "print('ok')")
+
+        with pytest.raises(ValueError, match='on_error'):
+            TestRunner(solution=sol, working_dir=str(tmp_path), on_error='unknown')
+
+    def test_clean_run_not_affected(self, tmp_path):
+        """on_error='default' must not interfere with completely clean solutions."""
+        sol = write_solution(tmp_path, "print(input()[::-1])")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path), on_error='default')
+
+        runner.test('abc')
+        inputs = get_input_files(tmp_path)
+        assert get_answer_file(inputs[0]).read_text().strip() == 'cba'
+
+
+# ---------------------------------------------------------------------------
+# use_WSL=True ignored on non-Windows
+# ---------------------------------------------------------------------------
+
+class TestWSLOnNonWindows:
+    def test_use_wsl_ignored(self, tmp_path):
+        """use_WSL=True must not crash or break execution on non-Windows."""
+        if platform.system() == 'Windows':
+            pytest.skip('WSL is meaningful on Windows; skip non-Windows check')
+
+        sol = write_solution(tmp_path, "print(int(input()) + 1)")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path), use_WSL=True)
+        runner.test('41')
+
+        inputs = get_input_files(tmp_path)
+        assert get_answer_file(inputs[0]).read_text().strip() == '42'
+
+    def test_compile_sol_use_wsl_ignored(self, tmp_path):
+        """compile_sol() must not crash with use_WSL=True on non-Windows."""
+        if platform.system() == 'Windows':
+            pytest.skip('WSL is meaningful on Windows; skip non-Windows check')
+
+        # A Python solution — compile_sol() returns early for .py, but the
+        # TestRunner constructor must succeed without errors.
+        sol = write_solution(tmp_path, "print('ok')")
+        runner = TestRunner(solution=sol, working_dir=str(tmp_path), use_WSL=True)
+        runner.test('x')
+
+        inputs = get_input_files(tmp_path)
+        assert get_answer_file(inputs[0]).read_text().strip() == 'ok'