| # SPDX-License-Identifier: GPL-2.0 |
| # |
| # Copyright (C) 2018 Masahiro Yamada <yamada.masahiro@socionext.com> |
| # |
| |
| """ |
| Kconfig unit testing framework. |
| |
| This provides fixture functions commonly used from test files. |
| """ |
| |
| import os |
| import pytest |
| import shutil |
| import subprocess |
| import tempfile |
| |
| CONF_PATH = os.path.abspath(os.path.join('scripts', 'kconfig', 'conf')) |
| |
| |
| class Conf: |
| """Kconfig runner and result checker. |
| |
| This class provides methods to run text-based interface of Kconfig |
| (scripts/kconfig/conf) and retrieve the resulted configuration, |
| stdout, and stderr. It also provides methods to compare those |
| results with expectations. |
| """ |
| |
| def __init__(self, request): |
| """Create a new Conf instance. |
| |
| request: object to introspect the requesting test module |
| """ |
| # the directory of the test being run |
| self._test_dir = os.path.dirname(str(request.fspath)) |
| |
| # runners |
| def _run_conf(self, mode, dot_config=None, out_file='.config', |
| interactive=False, in_keys=None, extra_env={}): |
| """Run text-based Kconfig executable and save the result. |
| |
| mode: input mode option (--oldaskconfig, --defconfig=<file> etc.) |
| dot_config: .config file to use for configuration base |
| out_file: file name to contain the output config data |
| interactive: flag to specify the interactive mode |
| in_keys: key inputs for interactive modes |
| extra_env: additional environments |
| returncode: exit status of the Kconfig executable |
| """ |
| command = [CONF_PATH, mode, 'Kconfig'] |
| |
| # Override 'srctree' environment to make the test as the top directory |
| extra_env['srctree'] = self._test_dir |
| |
| # Run Kconfig in a temporary directory. |
| # This directory is automatically removed when done. |
| with tempfile.TemporaryDirectory() as temp_dir: |
| |
| # if .config is given, copy it to the working directory |
| if dot_config: |
| shutil.copyfile(os.path.join(self._test_dir, dot_config), |
| os.path.join(temp_dir, '.config')) |
| |
| ps = subprocess.Popen(command, |
| stdin=subprocess.PIPE, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE, |
| cwd=temp_dir, |
| env=dict(os.environ, **extra_env)) |
| |
| # If input key sequence is given, feed it to stdin. |
| if in_keys: |
| ps.stdin.write(in_keys.encode('utf-8')) |
| |
| while ps.poll() is None: |
| # For interactive modes such as oldaskconfig, oldconfig, |
| # send 'Enter' key until the program finishes. |
| if interactive: |
| ps.stdin.write(b'\n') |
| |
| self.retcode = ps.returncode |
| self.stdout = ps.stdout.read().decode() |
| self.stderr = ps.stderr.read().decode() |
| |
| # Retrieve the resulted config data only when .config is supposed |
| # to exist. If the command fails, the .config does not exist. |
| # 'listnewconfig' does not produce .config in the first place. |
| if self.retcode == 0 and out_file: |
| with open(os.path.join(temp_dir, out_file)) as f: |
| self.config = f.read() |
| else: |
| self.config = None |
| |
| # Logging: |
| # Pytest captures the following information by default. In failure |
| # of tests, the captured log will be displayed. This will be useful to |
| # figure out what has happened. |
| |
| print("[command]\n{}\n".format(' '.join(command))) |
| |
| print("[retcode]\n{}\n".format(self.retcode)) |
| |
| print("[stdout]") |
| print(self.stdout) |
| |
| print("[stderr]") |
| print(self.stderr) |
| |
| if self.config is not None: |
| print("[output for '{}']".format(out_file)) |
| print(self.config) |
| |
| return self.retcode |
| |
| def oldaskconfig(self, dot_config=None, in_keys=None): |
| """Run oldaskconfig. |
| |
| dot_config: .config file to use for configuration base (optional) |
| in_key: key inputs (optional) |
| returncode: exit status of the Kconfig executable |
| """ |
| return self._run_conf('--oldaskconfig', dot_config=dot_config, |
| interactive=True, in_keys=in_keys) |
| |
| def oldconfig(self, dot_config=None, in_keys=None): |
| """Run oldconfig. |
| |
| dot_config: .config file to use for configuration base (optional) |
| in_key: key inputs (optional) |
| returncode: exit status of the Kconfig executable |
| """ |
| return self._run_conf('--oldconfig', dot_config=dot_config, |
| interactive=True, in_keys=in_keys) |
| |
| def olddefconfig(self, dot_config=None): |
| """Run olddefconfig. |
| |
| dot_config: .config file to use for configuration base (optional) |
| returncode: exit status of the Kconfig executable |
| """ |
| return self._run_conf('--olddefconfig', dot_config=dot_config) |
| |
| def defconfig(self, defconfig): |
| """Run defconfig. |
| |
| defconfig: defconfig file for input |
| returncode: exit status of the Kconfig executable |
| """ |
| defconfig_path = os.path.join(self._test_dir, defconfig) |
| return self._run_conf('--defconfig={}'.format(defconfig_path)) |
| |
| def _allconfig(self, mode, all_config): |
| if all_config: |
| all_config_path = os.path.join(self._test_dir, all_config) |
| extra_env = {'KCONFIG_ALLCONFIG': all_config_path} |
| else: |
| extra_env = {} |
| |
| return self._run_conf('--{}config'.format(mode), extra_env=extra_env) |
| |
| def allyesconfig(self, all_config=None): |
| """Run allyesconfig. |
| |
| all_config: fragment config file for KCONFIG_ALLCONFIG (optional) |
| returncode: exit status of the Kconfig executable |
| """ |
| return self._allconfig('allyes', all_config) |
| |
| def allmodconfig(self, all_config=None): |
| """Run allmodconfig. |
| |
| all_config: fragment config file for KCONFIG_ALLCONFIG (optional) |
| returncode: exit status of the Kconfig executable |
| """ |
| return self._allconfig('allmod', all_config) |
| |
| def allnoconfig(self, all_config=None): |
| """Run allnoconfig. |
| |
| all_config: fragment config file for KCONFIG_ALLCONFIG (optional) |
| returncode: exit status of the Kconfig executable |
| """ |
| return self._allconfig('allno', all_config) |
| |
| def alldefconfig(self, all_config=None): |
| """Run alldefconfig. |
| |
| all_config: fragment config file for KCONFIG_ALLCONFIG (optional) |
| returncode: exit status of the Kconfig executable |
| """ |
| return self._allconfig('alldef', all_config) |
| |
| def randconfig(self, all_config=None): |
| """Run randconfig. |
| |
| all_config: fragment config file for KCONFIG_ALLCONFIG (optional) |
| returncode: exit status of the Kconfig executable |
| """ |
| return self._allconfig('rand', all_config) |
| |
| def savedefconfig(self, dot_config): |
| """Run savedefconfig. |
| |
| dot_config: .config file for input |
| returncode: exit status of the Kconfig executable |
| """ |
| return self._run_conf('--savedefconfig', out_file='defconfig') |
| |
| def listnewconfig(self, dot_config=None): |
| """Run listnewconfig. |
| |
| dot_config: .config file to use for configuration base (optional) |
| returncode: exit status of the Kconfig executable |
| """ |
| return self._run_conf('--listnewconfig', dot_config=dot_config, |
| out_file=None) |
| |
| # checkers |
| def _read_and_compare(self, compare, expected): |
| """Compare the result with expectation. |
| |
| compare: function to compare the result with expectation |
| expected: file that contains the expected data |
| """ |
| with open(os.path.join(self._test_dir, expected)) as f: |
| expected_data = f.read() |
| return compare(self, expected_data) |
| |
| def _contains(self, attr, expected): |
| return self._read_and_compare( |
| lambda s, e: getattr(s, attr).find(e) >= 0, |
| expected) |
| |
| def _matches(self, attr, expected): |
| return self._read_and_compare(lambda s, e: getattr(s, attr) == e, |
| expected) |
| |
| def config_contains(self, expected): |
| """Check if resulted configuration contains expected data. |
| |
| expected: file that contains the expected data |
| returncode: True if result contains the expected data, False otherwise |
| """ |
| return self._contains('config', expected) |
| |
| def config_matches(self, expected): |
| """Check if resulted configuration exactly matches expected data. |
| |
| expected: file that contains the expected data |
| returncode: True if result matches the expected data, False otherwise |
| """ |
| return self._matches('config', expected) |
| |
| def stdout_contains(self, expected): |
| """Check if resulted stdout contains expected data. |
| |
| expected: file that contains the expected data |
| returncode: True if result contains the expected data, False otherwise |
| """ |
| return self._contains('stdout', expected) |
| |
| def stdout_matches(self, expected): |
| """Check if resulted stdout exactly matches expected data. |
| |
| expected: file that contains the expected data |
| returncode: True if result matches the expected data, False otherwise |
| """ |
| return self._matches('stdout', expected) |
| |
| def stderr_contains(self, expected): |
| """Check if resulted stderr contains expected data. |
| |
| expected: file that contains the expected data |
| returncode: True if result contains the expected data, False otherwise |
| """ |
| return self._contains('stderr', expected) |
| |
| def stderr_matches(self, expected): |
| """Check if resulted stderr exactly matches expected data. |
| |
| expected: file that contains the expected data |
| returncode: True if result matches the expected data, False otherwise |
| """ |
| return self._matches('stderr', expected) |
| |
| |
| @pytest.fixture(scope="module") |
| def conf(request): |
| """Create a Conf instance and provide it to test functions.""" |
| return Conf(request) |