tools/testing/kunit/kunit_config.py

   1 # SPDX-License-Identifier: GPL-2.0
   2 #
   3 # Builds a .config from a kunitconfig.
   4 #
   5 # Copyright (C) 2019, Google LLC.
   6 # Author: Felix Guo <felixguoxiuping@gmail.com>
   7 # Author: Brendan Higgins <brendanhiggins@google.com>
   8
   9 import collections
  10 import re
  11 from typing import List, Set
  12
  13 CONFIG_IS_NOT_SET_PATTERN = r'^# CONFIG_(\w+) is not set$'
  14 CONFIG_PATTERN = r'^CONFIG_(\w+)=(\S+|".*")$'
  15
  16 KconfigEntryBase = collections.namedtuple('KconfigEntryBase', ['name', 'value'])
  17
  18 class KconfigEntry(KconfigEntryBase):
  19
  20         def __str__(self) -> str:
  21                 if self.value == 'n':
  22                         return r'# CONFIG_%s is not set' % (self.name)
  23                 else:
  24                         return r'CONFIG_%s=%s' % (self.name, self.value)
  25
  26
  27 class KconfigParseError(Exception):
  28         """Error parsing Kconfig defconfig or .config."""
  29
  30
  31 class Kconfig(object):
  32         """Represents defconfig or .config specified using the Kconfig language."""
  33
  34         def __init__(self) -> None:
  35                 self._entries = []  # type: List[KconfigEntry]
  36
  37         def entries(self) -> Set[KconfigEntry]:
  38                 return set(self._entries)
  39
  40         def add_entry(self, entry: KconfigEntry) -> None:
  41                 self._entries.append(entry)
  42
  43         def is_subset_of(self, other: 'Kconfig') -> bool:
  44                 other_dict = {e.name: e.value for e in other.entries()}
  45                 for a in self.entries():
  46                         b = other_dict.get(a.name)
  47                         if b is None:
  48                                 if a.value == 'n':
  49                                         continue
  50                                 return False
  51                         elif a.value != b:
  52                                 return False
  53                 return True
  54
  55         def write_to_file(self, path: str) -> None:
  56                 with open(path, 'w') as f:
  57                         for entry in self.entries():
  58                                 f.write(str(entry) + '\n')
  59
  60         def parse_from_string(self, blob: str) -> None:
  61                 """Parses a string containing KconfigEntrys and populates this Kconfig."""
  62                 self._entries = []
  63                 is_not_set_matcher = re.compile(CONFIG_IS_NOT_SET_PATTERN)
  64                 config_matcher = re.compile(CONFIG_PATTERN)
  65                 for line in blob.split('\n'):
  66                         line = line.strip()
  67                         if not line:
  68                                 continue
  69
  70                         match = config_matcher.match(line)
  71                         if match:
  72                                 entry = KconfigEntry(match.group(1), match.group(2))
  73                                 self.add_entry(entry)
  74                                 continue
  75
  76                         empty_match = is_not_set_matcher.match(line)
  77                         if empty_match:
  78                                 entry = KconfigEntry(empty_match.group(1), 'n')
  79                                 self.add_entry(entry)
  80                                 continue
  81
  82                         if line[0] == '#':
  83                                 continue
  84                         else:
  85                                 raise KconfigParseError('Failed to parse: ' + line)
  86
  87         def read_from_file(self, path: str) -> None:
  88                 with open(path, 'r') as f:
  89                         self.parse_from_string(f.read())