libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/tools/kconfiglib/testsuite.py

3204 lines
101 KiB
Python
Raw Normal View History

将scons --menuconfig/--pyconfig/--pyconfig-silent统一调用kconfiglib
2024-04-19 08:48:32 +08:00
# Copyright (c) 2011-2019, Ulf Magnusson
# SPDX-License-Identifier: ISC
# This is the Kconfiglib test suite. It runs selftests on Kconfigs provided by
# us and tests compatibility with the C Kconfig implementation by comparing the
# output of Kconfiglib with the output of the scripts/kconfig/*conf utilities
# for different targets and defconfigs. It should be run from the top-level
# kernel directory with
#
# $ python Kconfiglib/testsuite.py
#
# Some additional options can be turned on by passing them as arguments. They
# default to off.
#
# - obsessive:
# By default, only valid arch/defconfig pairs are tested. In obsessive mode,
# every arch will be tested with every defconfig. Increases the testing time
# by an order of magnitude. Occasionally finds (usually obscure) bugs, and I
# make sure everything passes with it.
#
# - obsessive-min-config:
# Like obsessive, for the minimal configuation (defconfig) tests.
#
# - log:
# Log timestamped defconfig test failures to the file test_defconfig_fails.
# Handy in obsessive mode.
#
# For example, this commands runs the test suite in obsessive mode with logging
# enabled:
#
# $ python(3) Kconfiglib/testsuite.py obsessive log
#
# pypy works too, and runs most tests much faster than CPython.
#
# All tests should pass. Report regressions to ulfalizer a.t Google's email
# service.
import difflib
import errno
import os
import re
import shutil
import subprocess
import sys
import tempfile
import textwrap
from kconfiglib import Kconfig, Symbol, Choice, COMMENT, MENU, MenuNode, \
BOOL, TRISTATE, HEX, \
TRI_TO_STR, \
escape, unescape, \
expr_str, expr_items, split_expr, \
_ordered_unique, \
OR, AND, \
KconfigError
def shell(cmd):
with open(os.devnull, "w") as devnull:
subprocess.call(cmd, shell=True, stdout=devnull, stderr=devnull)
all_passed = True
def fail(msg=None):
global all_passed
all_passed = False
if msg is not None:
print("fail: " + msg)
def verify(cond, msg):
if not cond:
fail(msg)
def verify_equal(x, y):
if x != y:
fail("'{}' does not equal '{}'".format(x, y))
# Prevent accidental loading of configuration files by removing
# KCONFIG_ALLCONFIG from the environment
os.environ.pop("KCONFIG_ALLCONFIG", None)
obsessive = False
obsessive_min_config = False
log = False
def run_tests():
global obsessive, log
for s in sys.argv[1:]:
if s == "obsessive":
obsessive = True
print("Obsessive mode enabled")
elif s == "obsessive-min-config":
obsessive_min_config = True
print("Obsessive minimal config mode enabled")
elif s == "log":
log = True
print("Log mode enabled")
else:
print("Unrecognized option '{}'".format(s))
return
run_selftests()
run_compatibility_tests()
def run_selftests():
#
# Common helper functions. These all expect 'c' to hold the current
# configuration.
#
def verify_value(sym_name, val):
# Verifies that a symbol has a particular value.
if isinstance(val, int):
val = TRI_TO_STR[val]
sym = c.syms[sym_name]
verify(sym.str_value == val,
'expected {} to have the value "{}", had the value "{}"'
.format(sym_name, val, sym.str_value))
def assign_and_verify_value(sym_name, val, new_val):
# Assigns 'val' to a symbol and verifies that its value becomes
# 'new_val'. Assumes (and tests) that 'val' is valid for the
# symbol type.
if isinstance(new_val, int):
new_val = TRI_TO_STR[new_val]
sym = c.syms[sym_name]
old_val = sym.str_value
verify(sym.set_value(val),
"assigning '{}' to {} unexpectedly failed"
.format(val, sym_name))
verify(sym.str_value == new_val,
"expected {} to have the value '{}' after being assigned the "
"value '{}'. Instead, the value is '{}'. The old value was "
"'{}'."
.format(sym_name, new_val, val, sym.str_value, old_val))
def assign_and_verify(sym_name, user_val):
# Like assign_and_verify_value(), with the expected value being the
# value just set.
assign_and_verify_value(sym_name, user_val, user_val)
def assign_and_verify_user_value(sym_name, val, user_val, valid):
# Assigns a user value to the symbol and verifies the new user value.
# If valid is True, the user value is valid for the type, otherwise
# not. This is used to test the set_value() return value.
sym = c.syms[sym_name]
sym_old_user_val = sym.user_value
verify(sym.set_value(val) == valid,
"expected the user value '{}' to be {} for {}, was not"
.format(val, "valid" if valid else "invalid", sym_name))
verify(sym.user_value == user_val,
"the assigned user value '{}' wasn't reflected in user_value "
"on the symbol {}. Instead, the new user_value was '{}'. The "
"old user value was '{}'."
.format(user_val, sym_name, sym.user_value, sym_old_user_val))
#
# Selftests
#
print("Testing string literal lexing")
# Dummy empty configuration just to get a Kconfig object
c = Kconfig("Kconfiglib/tests/empty")
def verify_string_lex(s, expected):
# Verifies that a constant symbol with the name 'res' is produced from
# lexing 's'
res = c._tokenize("if " + s)[1].name
verify(res == expected,
"expected <{}> to produced the constant symbol <{}>, "
'produced <{}>'.format(s[1:-1], expected, res))
verify_string_lex(r""" "" """, "")
verify_string_lex(r""" '' """, "")
verify_string_lex(r""" "a" """, "a")
verify_string_lex(r""" 'a' """, "a")
verify_string_lex(r""" "ab" """, "ab")
verify_string_lex(r""" 'ab' """, "ab")
verify_string_lex(r""" "abc" """, "abc")
verify_string_lex(r""" 'abc' """, "abc")
verify_string_lex(r""" "'" """, "'")
verify_string_lex(r""" '"' """, '"')
verify_string_lex(r""" "\"" """, '"')
verify_string_lex(r""" '\'' """, "'")
verify_string_lex(r""" "\"\"" """, '""')
verify_string_lex(r""" '\'\'' """, "''")
verify_string_lex(r""" "\'" """, "'")
verify_string_lex(r""" '\"' """, '"')
verify_string_lex(r""" "\\" """, "\\")
verify_string_lex(r""" '\\' """, "\\")
verify_string_lex(r""" "\a\\'\b\c\"'d" """, 'a\\\'bc"\'d')
verify_string_lex(r""" '\a\\"\b\c\'"d' """, "a\\\"bc'\"d")
def verify_string_bad(s):
# Verifies that tokenizing 's' throws a KconfigError. Strips the first
# and last characters from 's' so we can use readable raw strings as
# input.
try:
c.eval_string(s)
except KconfigError:
pass
else:
fail("expected tokenization of {} to fail, didn't".format(s[1:-1]))
verify_string_bad(r""" " """)
verify_string_bad(r""" ' """)
verify_string_bad(r""" "' """)
verify_string_bad(r""" '" """)
verify_string_bad(r""" "\" """)
verify_string_bad(r""" '\' """)
verify_string_bad(r""" "foo """)
verify_string_bad(r""" 'foo """)
print("Testing escape() and unescape()")
def verify_escape_unescape(s, sesc):
# Verify that 's' escapes to 'sesc' and that 'sesc' unescapes to 's'
verify_equal(escape(s), sesc)
verify_equal(unescape(sesc), s)
verify_escape_unescape(r'' , r'' )
verify_escape_unescape(r'foo' , r'foo' )
verify_escape_unescape(r'"' , r'\"' )
verify_escape_unescape(r'""' , r'\"\"' )
verify_escape_unescape('\\' , r'\\' )
verify_escape_unescape(r'\\' , r'\\\\' )
verify_escape_unescape(r'\"' , r'\\\"' )
verify_escape_unescape(r'"ab\cd"ef"', r'\"ab\\cd\"ef\"')
# Backslashes before any character should be unescaped, not just before "
# and \
verify_equal(unescape(r"\afoo\b\c\\d\\\e\\\\f"), r"afoobc\d\e\\f")
print("Testing _ordered_unique()")
verify_equal(_ordered_unique([]), [])
verify_equal(_ordered_unique([1]), [1])
verify_equal(_ordered_unique([1, 2]), [1, 2])
verify_equal(_ordered_unique([1, 1]), [1])
verify_equal(_ordered_unique([1, 1, 2]), [1, 2])
verify_equal(_ordered_unique([1, 2, 1]), [1, 2])
verify_equal(_ordered_unique([1, 2, 2]), [1, 2])
verify_equal(_ordered_unique([1, 2, 3, 2, 1, 2, 3, 4, 3, 2, 1, 0]),
[1, 2, 3, 4, 0])
print("Testing expression evaluation")
c = Kconfig("Kconfiglib/tests/Keval", warn=False)
def verify_eval(expr, val):
res = c.eval_string(expr)
verify(res == val,
"'{}' evaluated to {}, expected {}".format(expr, res, val))
# No modules
verify_eval("n", 0)
verify_eval("m", 0)
verify_eval("y", 2)
verify_eval("'n'", 0)
verify_eval("'m'", 0)
verify_eval("'y'", 2)
verify_eval("M", 2)
# Modules
c.modules.set_value(2)
verify_eval("n", 0)
verify_eval("m", 1)
verify_eval("y", 2)
verify_eval("'n'", 0)
verify_eval("'m'", 1)
verify_eval("'y'", 2)
verify_eval("M", 1)
verify_eval("(Y || N) && (m && y)", 1)
# Non-bool/non-tristate symbols are always n in a tristate sense
verify_eval("Y_STRING", 0)
verify_eval("Y_STRING || m", 1)
# As are all constants besides y and m
verify_eval('"foo"', 0)
verify_eval('"foo" || "bar"', 0)
verify_eval('"foo" || m', 1)
# Test equality for symbols
verify_eval("N = N", 2)
verify_eval("N = n", 2)
verify_eval("N = 'n'", 2)
verify_eval("N != N", 0)
verify_eval("N != n", 0)
verify_eval("N != 'n'", 0)
verify_eval("M = M", 2)
verify_eval("M = m", 2)
verify_eval("M = 'm'", 2)
verify_eval("M != M", 0)
verify_eval("M != m", 0)
verify_eval("M != 'm'", 0)
verify_eval("Y = Y", 2)
verify_eval("Y = y", 2)
verify_eval("Y = 'y'", 2)
verify_eval("Y != Y", 0)
verify_eval("Y != y", 0)
verify_eval("Y != 'y'", 0)
verify_eval("N != M", 2)
verify_eval("N != Y", 2)
verify_eval("M != Y", 2)
verify_eval("Y_STRING = y", 2)
verify_eval("Y_STRING = 'y'", 2)
verify_eval('FOO_BAR_STRING = "foo bar"', 2)
verify_eval('FOO_BAR_STRING != "foo bar baz"', 2)
verify_eval('INT_37 = 37', 2)
verify_eval("INT_37 = '37'", 2)
verify_eval('HEX_0X37 = 0x37', 2)
verify_eval("HEX_0X37 = '0x37'", 2)
# These should also hold after 31847b67 (kconfig: allow use of relations
# other than (in)equality)
verify_eval("HEX_0X37 = '0x037'", 2)
verify_eval("HEX_0X37 = '0x0037'", 2)
# Constant symbol comparisons
verify_eval('"foo" != "bar"', 2)
verify_eval('"foo" = "bar"', 0)
verify_eval('"foo" = "foo"', 2)
# Undefined symbols get their name as their value
c.warn = False
verify_eval("'not_defined' = not_defined", 2)
verify_eval("not_defined_2 = not_defined_2", 2)
verify_eval("not_defined_1 != not_defined_2", 2)
# Test less than/greater than
# Basic evaluation
verify_eval("INT_37 < 38", 2)
verify_eval("38 < INT_37", 0)
verify_eval("INT_37 < '38'", 2)
verify_eval("'38' < INT_37", 0)
verify_eval("INT_37 < 138", 2)
verify_eval("138 < INT_37", 0)
verify_eval("INT_37 < '138'", 2)
verify_eval("'138' < INT_37", 0)
verify_eval("INT_37 < -138", 0)
verify_eval("-138 < INT_37", 2)
verify_eval("INT_37 < '-138'", 0)
verify_eval("'-138' < INT_37", 2)
verify_eval("INT_37 < 37", 0)
verify_eval("37 < INT_37", 0)
verify_eval("INT_37 < 36", 0)
verify_eval("36 < INT_37", 2)
# Different formats in comparison
verify_eval("INT_37 < 0x26", 2) # 38
verify_eval("INT_37 < 0x25", 0) # 37
verify_eval("INT_37 < 0x24", 0) # 36
verify_eval("HEX_0X37 < 56", 2) # 0x38
verify_eval("HEX_0X37 < 55", 0) # 0x37
verify_eval("HEX_0X37 < 54", 0) # 0x36
# Other int comparisons
verify_eval("INT_37 <= 38", 2)
verify_eval("INT_37 <= 37", 2)
verify_eval("INT_37 <= 36", 0)
verify_eval("INT_37 > 38", 0)
verify_eval("INT_37 > 37", 0)
verify_eval("INT_37 > 36", 2)
verify_eval("INT_37 >= 38", 0)
verify_eval("INT_37 >= 37", 2)
verify_eval("INT_37 >= 36", 2)
# Other hex comparisons
verify_eval("HEX_0X37 <= 0x38", 2)
verify_eval("HEX_0X37 <= 0x37", 2)
verify_eval("HEX_0X37 <= 0x36", 0)
verify_eval("HEX_0X37 > 0x38", 0)
verify_eval("HEX_0X37 > 0x37", 0)
verify_eval("HEX_0X37 > 0x36", 2)
verify_eval("HEX_0X37 >= 0x38", 0)
verify_eval("HEX_0X37 >= 0x37", 2)
verify_eval("HEX_0X37 >= 0x36", 2)
# A hex holding a value without a "0x" prefix should still be treated as
# hexadecimal
verify_eval("HEX_37 < 0x38", 2)
verify_eval("HEX_37 < 0x37", 0)
verify_eval("HEX_37 < 0x36", 0)
# Symbol comparisons
verify_eval("INT_37 < HEX_0X37", 2)
verify_eval("INT_37 > HEX_0X37", 0)
verify_eval("HEX_0X37 < INT_37 ", 0)
verify_eval("HEX_0X37 > INT_37 ", 2)
verify_eval("INT_37 < INT_37 ", 0)
verify_eval("INT_37 <= INT_37 ", 2)
verify_eval("INT_37 > INT_37 ", 0)
verify_eval("INT_37 <= INT_37 ", 2)
# Tristate value comparisons
verify_eval("n < n", 0)
verify_eval("n < m", 2)
verify_eval("n < y", 2)
verify_eval("n < N", 0)
verify_eval("n < M", 2)
verify_eval("n < Y", 2)
verify_eval("0 > n", 0)
verify_eval("1 > n", 2)
verify_eval("2 > n", 2)
verify_eval("m < n", 0)
verify_eval("m < m", 0)
verify_eval("m < y", 2)
# Strings compare lexicographically
verify_eval("'aa' < 'ab'", 2)
verify_eval("'aa' > 'ab'", 0)
verify_eval("'ab' < 'aa'", 0)
verify_eval("'ab' > 'aa'", 2)
# Comparisons where one of the operands doesn't parse as a number also give
# a lexicographic comparison
verify_eval("INT_37 < '37a' ", 2)
verify_eval("'37a' > INT_37", 2)
verify_eval("INT_37 <= '37a' ", 2)
verify_eval("'37a' >= INT_37", 2)
verify_eval("INT_37 >= '37a' ", 0)
verify_eval("INT_37 > '37a' ", 0)
verify_eval("'37a' < INT_37", 0)
verify_eval("'37a' <= INT_37", 0)
def verify_eval_bad(expr):
try:
c.eval_string(expr)
except KconfigError:
pass
else:
fail('expected eval_string("{}") to throw KconfigError, '
"didn't".format(expr))
# Verify that some bad stuff throws KconfigError's
verify_eval_bad("")
verify_eval_bad("&")
verify_eval_bad("|")
verify_eval_bad("!")
verify_eval_bad("(")
verify_eval_bad(")")
verify_eval_bad("=")
verify_eval_bad("(X")
verify_eval_bad("X)")
verify_eval_bad("X X")
verify_eval_bad("!X X")
verify_eval_bad("X !X")
verify_eval_bad("(X) X")
verify_eval_bad("X &&")
verify_eval_bad("&& X")
verify_eval_bad("X && && X")
verify_eval_bad("X && !&&")
verify_eval_bad("X ||")
verify_eval_bad("|| X")
print("Testing Symbol.__str__()/custom_str() and def_{int,hex,string}")
def verify_str(item, s):
verify_equal(str(item), s[1:-1])
def verify_custom_str(item, s):
verify_equal(item.custom_str(lambda sc: "[{}]".format(sc.name)),
s[1:-1])
c = Kconfig("Kconfiglib/tests/Kstr", warn=False)
c.modules.set_value(2)
verify_str(c.syms["UNDEFINED"], """
""")
verify_str(c.syms["BASIC_NO_PROMPT"], """
config BASIC_NO_PROMPT
bool
help
blah blah
blah blah blah
blah
""")
verify_str(c.syms["BASIC_PROMPT"], """
config BASIC_PROMPT
bool "basic"
""")
verify_str(c.syms["ADVANCED"], """
config ADVANCED
tristate "prompt" if DEP
default DEFAULT_1
default DEFAULT_2 if DEP
select SELECTED_1
select SELECTED_2 if DEP
imply IMPLIED_1
imply IMPLIED_2 if DEP
help
first help text
config ADVANCED
tristate "prompt 2"
menuconfig ADVANCED
tristate "prompt 3"
config ADVANCED
tristate
depends on (A || !B || (C && D) || !(E && F) || G = H || (I && !J && (K || L) && !(M || N) && O = P)) && DEP4 && DEP3
help
second help text
config ADVANCED
tristate "prompt 4" if VIS
depends on DEP4 && DEP3
""")
verify_custom_str(c.syms["ADVANCED"], """
config ADVANCED
tristate "prompt" if [DEP]
default [DEFAULT_1]
default [DEFAULT_2] if [DEP]
select [SELECTED_1]
select [SELECTED_2] if [DEP]
imply [IMPLIED_1]
imply [IMPLIED_2] if [DEP]
help
first help text
config ADVANCED
tristate "prompt 2"
menuconfig ADVANCED
tristate "prompt 3"
config ADVANCED
tristate
depends on ([A] || ![B] || ([C] && [D]) || !([E] && [F]) || [G] = [H] || ([I] && ![J] && ([K] || [L]) && !([M] || [N]) && [O] = [P])) && [DEP4] && [DEP3]
help
second help text
config ADVANCED
tristate "prompt 4" if [VIS]
depends on [DEP4] && [DEP3]
""")
verify_str(c.syms["ONLY_DIRECT_DEPS"], """
config ONLY_DIRECT_DEPS
int
depends on DEP1 && DEP2
""")
verify_str(c.syms["STRING"], """
config STRING
string
default "foo"
default "bar" if DEP
default STRING2
default STRING3 if DEP
""")
verify_str(c.syms["INT"], """
config INT
int
range 1 2
range FOO BAR
range BAZ QAZ if DEP
default 7 if DEP
""")
verify_str(c.syms["HEX"], """
config HEX
hex
range 0x100 0x200
range FOO BAR
range BAZ QAZ if DEP
default 0x123
""")
verify_str(c.modules, """
config MODULES
bool "MODULES"
option modules
""")
verify_str(c.syms["OPTIONS"], """
config OPTIONS
option allnoconfig_y
option defconfig_list
option env="ENV"
""")
verify_str(c.syms["CORRECT_PROP_LOCS_BOOL"], """
config CORRECT_PROP_LOCS_BOOL
bool "prompt 1"
default DEFAULT_1
default DEFAULT_2
select SELECT_1
select SELECT_2
imply IMPLY_1
imply IMPLY_2
depends on LOC_1
help
help 1
menuconfig CORRECT_PROP_LOCS_BOOL
bool "prompt 2"
default DEFAULT_3
default DEFAULT_4
select SELECT_3
select SELECT_4
imply IMPLY_3
imply IMPLY_4
depends on LOC_2
help
help 2
config CORRECT_PROP_LOCS_BOOL
bool "prompt 3"
default DEFAULT_5
default DEFAULT_6
select SELECT_5
select SELECT_6
imply IMPLY_5
imply IMPLY_6
depends on LOC_3
help
help 2
""")
verify_str(c.syms["CORRECT_PROP_LOCS_INT"], """
config CORRECT_PROP_LOCS_INT
int
range 1 2
range 3 4
depends on LOC_1
config CORRECT_PROP_LOCS_INT
int
range 5 6
range 7 8
depends on LOC_2
""")
verify_str(c.syms["PROMPT_ONLY"], """
config PROMPT_ONLY
prompt "prompt only"
""")
verify_custom_str(c.syms["CORRECT_PROP_LOCS_INT"], """
config CORRECT_PROP_LOCS_INT
int
range [1] [2]
range [3] [4]
depends on [LOC_1]
config CORRECT_PROP_LOCS_INT
int
range [5] [6]
range [7] [8]
depends on [LOC_2]
""")
print("Testing Choice.__str__()/custom_str()")
verify_str(c.named_choices["CHOICE"], """
choice CHOICE
tristate "foo"
default CHOICE_1
default CHOICE_2 if dep
""")
verify_str(c.named_choices["CHOICE"].nodes[0].next.item, """
choice
tristate "no name"
optional
""")
verify_str(c.named_choices["CORRECT_PROP_LOCS_CHOICE"], """
choice CORRECT_PROP_LOCS_CHOICE
bool
default CHOICE_3
depends on LOC_1
choice CORRECT_PROP_LOCS_CHOICE
bool
default CHOICE_4
depends on LOC_2
choice CORRECT_PROP_LOCS_CHOICE
bool
default CHOICE_5
depends on LOC_3
""")
verify_custom_str(c.named_choices["CORRECT_PROP_LOCS_CHOICE"], """
choice CORRECT_PROP_LOCS_CHOICE
bool
default [CHOICE_3]
depends on [LOC_1]
choice CORRECT_PROP_LOCS_CHOICE
bool
default [CHOICE_4]
depends on [LOC_2]
choice CORRECT_PROP_LOCS_CHOICE
bool
default [CHOICE_5]
depends on [LOC_3]
""")
print("Testing MenuNode.__str__()/custom_str() for menus and comments")
verify_str(c.syms["SIMPLE_MENU_HOOK"].nodes[0].next, """
menu "simple menu"
""")
verify_str(c.syms["ADVANCED_MENU_HOOK"].nodes[0].next, """
menu "advanced menu"
depends on A
visible if B && (C || D)
""")
verify_custom_str(c.syms["ADVANCED_MENU_HOOK"].nodes[0].next, """
menu "advanced menu"
depends on [A]
visible if [B] && ([C] || [D])
""")
verify_str(c.syms["SIMPLE_COMMENT_HOOK"].nodes[0].next, """
comment "simple comment"
""")
verify_str(c.syms["ADVANCED_COMMENT_HOOK"].nodes[0].next, """
comment "advanced comment"
depends on A && B
""")
verify_custom_str(c.syms["ADVANCED_COMMENT_HOOK"].nodes[0].next, """
comment "advanced comment"
depends on [A] && [B]
""")
print("Testing {MenuNode,Symbol,Choice}.orig_*")
# Just test some corner cases here re. MenuNode.orig_*. They are already
# indirectly tested above. Use MenuNode.__str__() as a proxy.
verify_str(c.syms["DEP_REM_CORNER_CASES"], """
config DEP_REM_CORNER_CASES
bool
default A
depends on n
config DEP_REM_CORNER_CASES
bool
default B if n
config DEP_REM_CORNER_CASES
bool
default C
depends on m && MODULES
config DEP_REM_CORNER_CASES
bool
default D if A
config DEP_REM_CORNER_CASES
bool
default E if !E1
default F if F1 = F2
default G if G1 || H1
depends on !H
config DEP_REM_CORNER_CASES
bool
default H
depends on "foo" = "bar"
config DEP_REM_CORNER_CASES
bool "prompt" if FOO || BAR
depends on BAZ && QAZ
""")
# Test {Symbol,Choice}.orig_*
def verify_deps(elms, dep_index, expected):
verify_equal(" ".join(expr_str(elm[dep_index]) for elm in elms),
expected)
verify_deps(c.syms["BOOL_SYM_ORIG"].orig_defaults, 1, "DEP y y")
verify_deps(c.syms["BOOL_SYM_ORIG"].orig_selects, 1, "y DEP y")
verify_deps(c.syms["BOOL_SYM_ORIG"].orig_implies, 1, "y y DEP")
verify_deps(c.syms["INT_SYM_ORIG"].orig_ranges, 2, "DEP y DEP")
verify_deps(c.named_choices["CHOICE_ORIG"].orig_defaults, 1, "y DEP DEP")
print("Testing Symbol.__repr__()")
def verify_repr(item, s):
verify_equal(repr(item) + "\n", s[1:])
c = Kconfig("Kconfiglib/tests/Krepr", warn=False)
verify_repr(c.n, """
<symbol n, tristate, value n, constant>
""")
verify_repr(c.m, """
<symbol m, tristate, value m, constant>
""")
verify_repr(c.y, """
<symbol y, tristate, value y, constant>
""")
verify_repr(c.syms["UNDEFINED"], """
<symbol UNDEFINED, unknown, value "UNDEFINED", visibility n, direct deps n, undefined>
""")
verify_repr(c.syms["BASIC"], """
<symbol BASIC, bool, value y, visibility n, direct deps y, Kconfiglib/tests/Krepr:9>
""")
verify_repr(c.syms["VISIBLE"], """
<symbol VISIBLE, bool, "visible", value n, visibility y, direct deps y, Kconfiglib/tests/Krepr:14>
""")
c.syms["VISIBLE"].set_value(2)
c.syms["STRING"].set_value("foo")
verify_repr(c.syms["VISIBLE"], """
<symbol VISIBLE, bool, "visible", value y, user value y, visibility y, direct deps y, Kconfiglib/tests/Krepr:14>
""")
verify_repr(c.syms["STRING"], """
<symbol STRING, string, "visible", value "foo", user value "foo", visibility y, direct deps y, Kconfiglib/tests/Krepr:17>
""")
verify_repr(c.syms["DIR_DEP_N"], """
<symbol DIR_DEP_N, unknown, value "DIR_DEP_N", visibility n, direct deps n, Kconfiglib/tests/Krepr:20>
""")
verify_repr(c.syms["OPTIONS"], """
<symbol OPTIONS, unknown, value "OPTIONS", visibility n, allnoconfig_y, is the defconfig_list symbol, from environment variable ENV, direct deps y, Kconfiglib/tests/Krepr:23>
""")
verify_repr(c.syms["MULTI_DEF"], """
<symbol MULTI_DEF, unknown, value "MULTI_DEF", visibility n, direct deps y, Kconfiglib/tests/Krepr:28, Kconfiglib/tests/Krepr:29>
""")
verify_repr(c.syms["CHOICE_1"], """
<symbol CHOICE_1, tristate, "choice sym", value n, visibility m, choice symbol, direct deps m, Kconfiglib/tests/Krepr:36>
""")
verify_repr(c.modules, """
<symbol MODULES, bool, value y, visibility n, is the modules symbol, direct deps y, Kconfiglib/tests/Krepr:1>
""")
print("Testing Choice.__repr__()")
verify_repr(c.named_choices["CHOICE"], """
<choice CHOICE, tristate, "choice", mode m, visibility y, Kconfiglib/tests/Krepr:33>
""")
c.named_choices["CHOICE"].set_value(2)
verify_repr(c.named_choices["CHOICE"], """
<choice CHOICE, tristate, "choice", mode y, user mode y, CHOICE_1 selected, visibility y, Kconfiglib/tests/Krepr:33>
""")
c.syms["CHOICE_2"].set_value(2)
verify_repr(c.named_choices["CHOICE"], """
<choice CHOICE, tristate, "choice", mode y, user mode y, CHOICE_2 selected, CHOICE_2 selected by user, visibility y, Kconfiglib/tests/Krepr:33>
""")
c.named_choices["CHOICE"].set_value(1)
verify_repr(c.named_choices["CHOICE"], """
<choice CHOICE, tristate, "choice", mode m, user mode m, CHOICE_2 selected by user (overridden), visibility y, Kconfiglib/tests/Krepr:33>
""")
verify_repr(c.syms["CHOICE_HOOK"].nodes[0].next.item, """
<choice, tristate, "optional choice", mode n, visibility n, optional, Kconfiglib/tests/Krepr:46>
""")
print("Testing MenuNode.__repr__()")
verify_repr(c.syms["BASIC"].nodes[0], """
<menu node for symbol BASIC, deps y, has help, has next, Kconfiglib/tests/Krepr:9>
""")
verify_repr(c.syms["DIR_DEP_N"].nodes[0], """
<menu node for symbol DIR_DEP_N, deps n, has next, Kconfiglib/tests/Krepr:20>
""")
verify_repr(c.syms["MULTI_DEF"].nodes[0], """
<menu node for symbol MULTI_DEF, deps y, has next, Kconfiglib/tests/Krepr:28>
""")
verify_repr(c.syms["MULTI_DEF"].nodes[1], """
<menu node for symbol MULTI_DEF, deps y, has next, Kconfiglib/tests/Krepr:29>
""")
verify_repr(c.syms["MENUCONFIG"].nodes[0], """
<menu node for symbol MENUCONFIG, is menuconfig, deps y, has next, Kconfiglib/tests/Krepr:31>
""")
verify_repr(c.named_choices["CHOICE"].nodes[0], """
<menu node for choice CHOICE, prompt "choice" (visibility y), deps y, has child, has next, Kconfiglib/tests/Krepr:33>
""")
verify_repr(c.syms["CHOICE_HOOK"].nodes[0].next, """
<menu node for choice, prompt "optional choice" (visibility n), deps y, has next, Kconfiglib/tests/Krepr:46>
""")
verify_repr(c.syms["NO_VISIBLE_IF_HOOK"].nodes[0].next, """
<menu node for menu, prompt "no visible if" (visibility y), deps y, 'visible if' deps y, has next, Kconfiglib/tests/Krepr:53>
""")
verify_repr(c.syms["VISIBLE_IF_HOOK"].nodes[0].next, """
<menu node for menu, prompt "visible if" (visibility y), deps y, 'visible if' deps m, has next, Kconfiglib/tests/Krepr:58>
""")
verify_repr(c.syms["COMMENT_HOOK"].nodes[0].next, """
<menu node for comment, prompt "comment" (visibility y), deps y, Kconfiglib/tests/Krepr:64>
""")
print("Testing Kconfig.__repr__()")
verify_repr(c, """
<configuration with 15 symbols, main menu prompt "Main menu", srctree is current directory, config symbol prefix "CONFIG_", warnings disabled, printing of warnings to stderr enabled, undef. symbol assignment warnings disabled, overriding symbol assignment warnings enabled, redundant symbol assignment warnings enabled>
""")
os.environ["srctree"] = "Kconfiglib"
os.environ["CONFIG_"] = "CONFIG_ value"
c = Kconfig("tests/Krepr", warn=False)
c.warn = True
c.warn_to_stderr = False
c.warn_assign_override = False
c.warn_assign_redun = False
c.warn_assign_undef = True
verify_repr(c, """
<configuration with 15 symbols, main menu prompt "Main menu", srctree "Kconfiglib", config symbol prefix "CONFIG_ value", warnings enabled, printing of warnings to stderr disabled, undef. symbol assignment warnings enabled, overriding symbol assignment warnings disabled, redundant symbol assignment warnings disabled>
""")
os.environ.pop("srctree", None)
os.environ.pop("CONFIG_", None)
print("Testing tricky help strings")
c = Kconfig("Kconfiglib/tests/Khelp")
def verify_help(node, s):
verify_equal(node.help, s[1:-1])
verify_help(c.syms["TWO_HELP_STRINGS"].nodes[0], """
first help string
""")
verify_help(c.syms["TWO_HELP_STRINGS"].nodes[1], """
second help string
""")
verify_help(c.syms["NO_BLANK_AFTER_HELP"].nodes[0], """
help for
NO_BLANK_AFTER_HELP
""")
verify_help(c.named_choices["CHOICE_HELP"].nodes[0], """
help for
CHOICE_HELP
""")
verify_help(c.syms["HELP_TERMINATED_BY_COMMENT"].nodes[0], """
a
b
c
""")
verify_help(c.syms["TRICKY_HELP"].nodes[0], """
a
b
c
d
e
f
g
h
i
""")
print("Testing locations, source/rsource/gsource/grsource, and "
"Kconfig.kconfig_filenames")
def verify_locations(nodes, *expected_locs):
verify(len(nodes) == len(expected_locs),
"Wrong number of locations for " + repr(nodes))
for node, expected_loc in zip(nodes, expected_locs):
node_loc = "{}:{}".format(node.filename, node.linenr)
verify(node_loc == expected_loc,
"expected {} to have the location {}, had the location {}"
.format(repr(node), expected_loc, node_loc))
# Expanded in the 'source' statement in Klocation
os.environ["TESTS_DIR_FROM_ENV"] = "tests"
os.environ["SUB_DIR_FROM_ENV"] = "sub"
os.environ["_SOURCED"] = "_sourced"
os.environ["_RSOURCED"] = "_rsourced"
os.environ["_GSOURCED"] = "_gsourced"
os.environ["_GRSOURCED"] = "_grsourced"
# Test twice, with $srctree as a relative and an absolute path,
# respectively
for srctree in "Kconfiglib", os.path.abspath("Kconfiglib"):
os.environ["srctree"] = srctree
# Has symbol with empty help text, so disable warnings
c = Kconfig("tests/Klocation", warn=False)
verify_locations(c.syms["UNDEFINED"].nodes)
verify_equal(c.syms["UNDEFINED"].name_and_loc, "UNDEFINED (undefined)")
verify_locations(c.syms["ONE_DEF"].nodes, "tests/Klocation:4")
verify_equal(c.syms["ONE_DEF"].name_and_loc,
"ONE_DEF (defined at tests/Klocation:4)")
verify_locations(c.syms["TWO_DEF"].nodes,
"tests/Klocation:7",
"tests/Klocation:10")
verify_equal(c.syms["TWO_DEF"].name_and_loc,
"TWO_DEF (defined at tests/Klocation:7, tests/Klocation:10)")
verify_locations(c.syms["MANY_DEF"].nodes,
"tests/Klocation:13",
"tests/Klocation:43",
"tests/Klocation:45",
"tests/Klocation_sourced:3",
"tests/sub/Klocation_rsourced:2",
"tests/sub/Klocation_gsourced1:1",
"tests/sub/Klocation_gsourced2:1",
"tests/sub/Klocation_gsourced1:1",
"tests/sub/Klocation_gsourced2:1",
"tests/sub/Klocation_grsourced1:1",
"tests/sub/Klocation_grsourced2:1",
"tests/sub/Klocation_grsourced1:1",
"tests/sub/Klocation_grsourced2:1",
"tests/Klocation:78")
verify_locations(c.named_choices["CHOICE_ONE_DEF"].nodes,
"tests/Klocation_sourced:5")
verify_equal(c.named_choices["CHOICE_ONE_DEF"].name_and_loc,
"<choice CHOICE_ONE_DEF> (defined at tests/Klocation_sourced:5)")
verify_locations(c.named_choices["CHOICE_TWO_DEF"].nodes,
"tests/Klocation_sourced:9",
"tests/Klocation_sourced:13")
verify_equal(c.named_choices["CHOICE_TWO_DEF"].name_and_loc,
"<choice CHOICE_TWO_DEF> (defined at tests/Klocation_sourced:9, tests/Klocation_sourced:13)")
verify_locations([c.syms["MENU_HOOK"].nodes[0].next],
"tests/Klocation_sourced:20")
verify_locations([c.syms["COMMENT_HOOK"].nodes[0].next],
"tests/Klocation_sourced:26")
# Test Kconfig.kconfig_filenames
verify_equal(c.kconfig_filenames, [
"tests/Klocation",
"tests/Klocation_sourced",
"tests/sub/Klocation_rsourced",
"tests/sub/Klocation_gsourced1",
"tests/sub/Klocation_gsourced2",
"tests/sub/Klocation_gsourced1",
"tests/sub/Klocation_gsourced2",
"tests/sub/Klocation_grsourced1",
"tests/sub/Klocation_grsourced2",
"tests/sub/Klocation_grsourced1",
"tests/sub/Klocation_grsourced2"
])
# Test recursive 'source' detection
try:
Kconfig("tests/Krecursive1")
except KconfigError as e:
verify_equal(str(e), """
tests/Krecursive2:1: recursive 'source' of 'tests/Krecursive1' detected. Check that environment variables are set correctly.
Include path:
tests/Krecursive1:1
tests/Krecursive2:1
"""[:-1])
except:
fail("recursive 'source' raised wrong exception")
else:
fail("recursive 'source' did not raise exception")
# Verify that source and rsource throw exceptions for missing files
# TODO: Make an exception test helper
try:
Kconfig("tests/Kmissingsource")
except KconfigError as e:
if "not found" not in str(e):
fail("'source' with missing file raised wrong KconfigError")
except:
fail("'source' with missing file raised wrong exception")
else:
fail("'source' with missing file did not raise exception")
try:
Kconfig("tests/Kmissingrsource")
except KconfigError as e:
if "not found" not in str(e):
fail("'rsource' with missing file raised wrong KconfigError")
except:
fail("'rsource' with missing file raised wrong exception")
else:
fail("'rsource' with missing file did not raise exception")
# Test a tricky case involving symlinks. $srctree is tests/symlink, which
# points to tests/sub/sub, meaning tests/symlink/.. != tests/. Previously,
# using 'rsource' from a file sourced with an absolute path triggered an
# unsafe relpath() with tests/symlink/.. in it, crashing.
os.environ["srctree"] = "Kconfiglib/tests/symlink"
os.environ["KCONFIG_SYMLINK_2"] = os.path.abspath(
"Kconfiglib/tests/sub/Kconfig_symlink_2")
if not os.path.isabs(
Kconfig("Kconfig_symlink_1").syms["FOUNDME"].nodes[0].filename):
fail("Symlink + rsource issues")
print("Testing Kconfig.node_iter()")
# Reuse tests/Klocation. The node_iter(unique_syms=True) case already gets
# plenty of testing from write_config() as well.
os.environ["srctree"] = "Kconfiglib"
c = Kconfig("tests/Klocation", warn=False)
verify_equal(
[node.item.name for node in c.node_iter()
if isinstance(node.item, Symbol)],
["ONE_DEF", "TWO_DEF", "TWO_DEF", "MANY_DEF", "HELP_1", "HELP_2",
"HELP_3", "MANY_DEF", "MANY_DEF", "MANY_DEF", "MENU_HOOK",
"COMMENT_HOOK"] + 10*["MANY_DEF"])
verify_equal(
[node.item.name for node in c.node_iter(True)
if isinstance(node.item, Symbol)],
["ONE_DEF", "TWO_DEF", "MANY_DEF", "HELP_1", "HELP_2", "HELP_3",
"MENU_HOOK", "COMMENT_HOOK"])
verify_equal(
[node.prompt[0] for node in c.node_iter()
if not isinstance(node.item, Symbol)],
["one-def choice", "two-def choice 1", "two-def choice 2",
"menu", "comment"])
verify_equal(
[node.prompt[0] for node in c.node_iter(True)
if not isinstance(node.item, Symbol)],
["one-def choice", "two-def choice 1", "two-def choice 2",
"menu", "comment"])
print("Testing MenuNode.include_path")
os.environ["srctree"] = "Kconfiglib/tests"
c = Kconfig("Kinclude_path")
def verify_node_path(node, *expected):
if node.include_path != expected:
fail("Wrong include path for node {!r}. Got {}, expected {}."
.format(node, node.include_path, expected))
def verify_sym_path(sym_name, node_i, *expected):
verify_node_path(c.syms[sym_name].nodes[node_i], *expected)
verify_sym_path("TOP", 0)
verify_sym_path("TOP", 1)
verify_sym_path("TOP", 2)
verify_sym_path("ONE_DOWN", 0, ("Kinclude_path", 4))
verify_sym_path("ONE_DOWN", 1, ("Kinclude_path", 4))
verify_sym_path("ONE_DOWN", 2, ("Kinclude_path", 4))
verify_sym_path("ONE_DOWN", 3, ("Kinclude_path", 9))
verify_sym_path("ONE_DOWN", 4, ("Kinclude_path", 9))
verify_sym_path("ONE_DOWN", 5, ("Kinclude_path", 9))
verify_sym_path("TWO_DOWN", 0,
("Kinclude_path", 4), ("Kinclude_path_sourced_1", 4))
verify_sym_path("TWO_DOWN", 1,
("Kinclude_path", 4), ("Kinclude_path_sourced_1", 9))
verify_sym_path("TWO_DOWN", 2,
("Kinclude_path", 9), ("Kinclude_path_sourced_1", 4))
verify_sym_path("TWO_DOWN", 3,
("Kinclude_path", 9), ("Kinclude_path_sourced_1", 9))
verify_node_path(c.top_node)
verify_node_path(c.menus[0], ("Kinclude_path", 4), ("Kinclude_path_sourced_1", 4))
verify_node_path(c.comments[0], ("Kinclude_path", 4), ("Kinclude_path_sourced_1", 4))
verify_node_path(c.choices[0].nodes[0], ("Kinclude_path", 4), ("Kinclude_path_sourced_1", 4))
os.environ.pop("srctree", None)
print("Testing Kconfig.choices/menus/comments")
c = Kconfig("Kconfiglib/tests/Kitemlists")
def verify_prompts(items, *expected_prompts):
verify(len(items) == len(expected_prompts),
"Wrong number of prompts for {}".format(items))
for item, expected_prompt in zip(items, expected_prompts):
if not isinstance(item, MenuNode):
item = item.nodes[0]
verify(item.prompt[0] == expected_prompt,
"Wrong prompt for {}, expected '{}'"
.format(repr(item), expected_prompt))
verify_prompts(c.choices, "choice 1", "choice 2", "choice 3", "choice 2")
verify_prompts(c.menus, "menu 1", "menu 2", "menu 3", "menu 4", "menu 5")
verify_prompts(c.comments, "comment 1", "comment 2", "comment 3")
print("Testing Symbol/Choice.direct_dep")
c = Kconfig("Kconfiglib/tests/Kdirdep")
verify_equal(expr_str(c.syms["NO_DEP_SYM"].direct_dep), 'y')
verify_equal(expr_str(c.syms["DEP_SYM"].direct_dep), "A || (B && C) || !D")
verify_equal(expr_str(c.named_choices["NO_DEP_CHOICE"].direct_dep), 'y')
verify_equal(expr_str(c.named_choices["DEP_CHOICE"].direct_dep),
"A || B || C")
print("Testing expr_items()")
c = Kconfig("Kconfiglib/tests/Kexpr_items")
def verify_expr_items(expr, *sym_names):
verify_equal(tuple(sorted(item.name for item in expr_items(expr))),
sym_names)
verify_expr_items(
c.syms["TEST"].defaults[0][0],
"A", "B", "C", "D", "E", "F", "G", "H"
)
verify_expr_items(
c.syms["TEST_CHOICE"].nodes[0].prompt[1],
"A", "CHOICE"
)
print("Testing MenuNode/Symbol/Choice.referenced")
c = Kconfig("Kconfiglib/tests/Kreferenced", warn=False)
def verify_deps(item, *dep_names):
verify_equal(tuple(sorted(item.name for item in item.referenced)),
dep_names)
verify_deps(c.top_node, "y")
verify_deps(c.syms["NO_REFS"].nodes[0], "y")
verify_deps(c.syms["JUST_DEPENDS_ON_REFS"].nodes[0], "A", "B")
verify_deps(c.syms["LOTS_OF_REFS"].nodes[0],
*(chr(n) for n in range(ord("A"), ord("Z") + 1)))
verify_deps(c.syms["INT_REFS"].nodes[0],
"A", "B", "C", "D", "E", "F", "G", "H", "y")
verify_deps(c.syms["CHOICE_REF"].nodes[0], "CHOICE")
verify_deps(c.menus[0], "A", "B", "C", "D")
verify_deps(c.comments[0], "A", "B")
verify_deps(c.syms["MULTI_DEF_SYM"], "A", "B", "C", "y")
verify_deps(c.named_choices["MULTI_DEF_CHOICE"], "A", "B", "C")
print("Testing split_expr()")
c = Kconfig("Kconfiglib/tests/empty")
c.warn = False
def verify_split(to_split, op, operand_strs):
# The same hackage as in Kconfig.eval_string()
c._tokens = c._tokenize("if " + to_split)[1:]
c._tokens_i = 0
operands = split_expr(c._parse_expr(False), op)
verify(len(operands) == len(operand_strs),
"Wrong number of operands when {} was split by {}"
.format(to_split, "OR" if op == OR else "AND"))
for operand, operand_str in zip(operands, operand_strs):
verify_equal(expr_str(operand), operand_str)
verify_split("A", OR, ("A", ))
verify_split("!A", OR, ("!A", ))
verify_split("A = B", OR, ("A = B", ))
verify_split("A && B", OR, ("A && B", ))
verify_split("A || B", OR, ("A", "B" ))
verify_split("(A || B) || C", OR, ("A", "B", "C" ))
verify_split("A || (B || C)", OR, ("A", "B", "C" ))
verify_split("A || !(B || C)", OR, ("A", "!(B || C)" ))
verify_split("A || (B && (C || D))", OR, ("A", "B && (C || D)"))
verify_split("(A && (B || C)) || D", OR, ("A && (B || C)", "D"))
verify_split("A", AND, ("A", ))
verify_split("!A", AND, ("!A", ))
verify_split("A = B", AND, ("A = B", ))
verify_split("A || B", AND, ("A || B", ))
verify_split("A && B", AND, ("A", "B" ))
verify_split("(A && B) && C", AND, ("A", "B", "C" ))
verify_split("A && (B && C)", AND, ("A", "B", "C" ))
verify_split("A && !(B && C)", AND, ("A", "!(B && C)" ))
verify_split("A && (B || (C && D))", AND, ("A", "B || (C && D)"))
verify_split("(A || (B && C)) && D", AND, ("A || (B && C)", "D"))
print("Testing visibility")
c = Kconfig("Kconfiglib/tests/Kvisibility")
def verify_visibility(item, no_module_vis, module_vis):
c.modules.set_value(0)
verify(item.visibility == no_module_vis,
"expected {} to have visibility {} without modules, had "
"visibility {}".
format(repr(item), no_module_vis, item.visibility))
c.modules.set_value(2)
verify(item.visibility == module_vis,
"expected {} to have visibility {} with modules, had "
"visibility {}".
format(repr(item), module_vis, item.visibility))
# Symbol visibility
verify_visibility(c.syms["NO_PROMPT"], 0, 0)
verify_visibility(c.syms["BOOL_N"], 0, 0)
verify_visibility(c.syms["BOOL_M"], 0, 2)
verify_visibility(c.syms["BOOL_MOD"], 2, 2)
verify_visibility(c.syms["BOOL_Y"], 2, 2)
verify_visibility(c.syms["TRISTATE_M"], 0, 1)
verify_visibility(c.syms["TRISTATE_MOD"], 2, 1)
verify_visibility(c.syms["TRISTATE_Y"], 2, 2)
verify_visibility(c.syms["BOOL_IF_N"], 0, 0)
verify_visibility(c.syms["BOOL_IF_M"], 0, 2)
verify_visibility(c.syms["BOOL_IF_Y"], 2, 2)
verify_visibility(c.syms["BOOL_MENU_N"], 0, 0)
verify_visibility(c.syms["BOOL_MENU_M"], 0, 2)
verify_visibility(c.syms["BOOL_MENU_Y"], 2, 2)
verify_visibility(c.syms["BOOL_CHOICE_N"], 0, 0)
# Non-tristate symbols in tristate choices are only visible if the choice
# is in y mode
# The choice can't be brought to y mode because of the 'if m'
verify_visibility(c.syms["BOOL_CHOICE_M"], 0, 0)
c.syms["BOOL_CHOICE_M"].choice.set_value(2)
verify_visibility(c.syms["BOOL_CHOICE_M"], 0, 0)
# The choice gets y mode only when running without modules, because it
# defaults to m mode
verify_visibility(c.syms["BOOL_CHOICE_Y"], 2, 0)
c.syms["BOOL_CHOICE_Y"].choice.set_value(2)
# When set to y mode, the choice symbol becomes visible both with and
# without modules
verify_visibility(c.syms["BOOL_CHOICE_Y"], 2, 2)
verify_visibility(c.syms["TRISTATE_IF_N"], 0, 0)
verify_visibility(c.syms["TRISTATE_IF_M"], 0, 1)
verify_visibility(c.syms["TRISTATE_IF_Y"], 2, 2)
verify_visibility(c.syms["TRISTATE_MENU_N"], 0, 0)
verify_visibility(c.syms["TRISTATE_MENU_M"], 0, 1)
verify_visibility(c.syms["TRISTATE_MENU_Y"], 2, 2)
verify_visibility(c.syms["TRISTATE_CHOICE_N"], 0, 0)
verify_visibility(c.syms["TRISTATE_CHOICE_M"], 0, 1)
verify_visibility(c.syms["TRISTATE_CHOICE_Y"], 2, 2)
verify_visibility(c.named_choices["BOOL_CHOICE_N"], 0, 0)
verify_visibility(c.named_choices["BOOL_CHOICE_M"], 0, 2)
verify_visibility(c.named_choices["BOOL_CHOICE_Y"], 2, 2)
verify_visibility(c.named_choices["TRISTATE_CHOICE_N"], 0, 0)
verify_visibility(c.named_choices["TRISTATE_CHOICE_M"], 0, 1)
verify_visibility(c.named_choices["TRISTATE_CHOICE_Y"], 2, 2)
verify_visibility(c.named_choices["TRISTATE_CHOICE_IF_M_AND_Y"], 0, 1)
verify_visibility(c.named_choices["TRISTATE_CHOICE_MENU_N_AND_Y"], 0, 0)
# Verify that 'visible if' visibility gets propagated to prompts
verify_visibility(c.syms["VISIBLE_IF_N"], 0, 0)
verify_visibility(c.syms["VISIBLE_IF_M"], 0, 1)
verify_visibility(c.syms["VISIBLE_IF_Y"], 2, 2)
verify_visibility(c.syms["VISIBLE_IF_M_2"], 0, 1)
# Verify that string/int/hex symbols with m visibility accept a user value
assign_and_verify("STRING_m", "foo bar")
assign_and_verify("INT_m", "123")
assign_and_verify("HEX_m", "0x123")
print("Testing .assignable")
c = Kconfig("Kconfiglib/tests/Kassignable")
def verify_assignable_imp(item, assignable_no_modules, assignable_modules):
# Verifies the assignable values for 'item', with and without modules.
for modules_val, assignable in (0, assignable_no_modules), \
(2, assignable_modules):
c.modules.set_value(modules_val)
module_msg = "without modules" if modules_val == 0 else \
"with modules"
verify(item.assignable == assignable,
"Incorrect assignable values for {} {}. Should be {}, "
"was {}."
.format(item.name, module_msg, assignable, item.assignable))
# Verify that the values can actually be assigned too
for val in item.assignable:
item.set_value(val)
verify(item.tri_value == val,
"Unable to set {} to {} {}, even though it was in "
".assignable".format(item.name, val, module_msg))
def verify_assignable(sym_name, assignable_no_modules, assignable_modules):
verify_assignable_imp(c.syms[sym_name],
assignable_no_modules,
assignable_modules)
def verify_const_unassignable(sym_name):
verify_assignable_imp(c.const_syms[sym_name], (), ())
# Things that shouldn't be .assignable
verify_const_unassignable("n")
verify_const_unassignable("m")
verify_const_unassignable("y")
verify_const_unassignable("const")
verify_assignable("UNDEFINED", (), ())
verify_assignable("NO_PROMPT", (), ())
verify_assignable("STRING", (), ())
verify_assignable("INT", (), ())
verify_assignable("HEX", (), ())
# Non-selected symbols
verify_assignable("Y_VIS_BOOL", (0, 2), (0, 2))
verify_assignable("M_VIS_BOOL", ( ), (0, 2)) # Vis. promoted
verify_assignable("N_VIS_BOOL", ( ), ( ))
verify_assignable("Y_VIS_TRI", (0, 2), (0, 1, 2))
verify_assignable("M_VIS_TRI", ( ), (0, 1 ))
verify_assignable("N_VIS_TRI", ( ), ( ))
# Symbols selected to y
verify_assignable("Y_SEL_Y_VIS_BOOL", (2,), (2,))
verify_assignable("Y_SEL_M_VIS_BOOL", ( ), (2,)) # Vis. promoted
verify_assignable("Y_SEL_N_VIS_BOOL", ( ), ( ))
verify_assignable("Y_SEL_Y_VIS_TRI", (2,), (2,))
verify_assignable("Y_SEL_M_VIS_TRI", ( ), (2,))
verify_assignable("Y_SEL_N_VIS_TRI", ( ), ( ))
# Symbols selected to m
verify_assignable("M_SEL_Y_VIS_BOOL", (2,), ( 2,)) # Value promoted
verify_assignable("M_SEL_M_VIS_BOOL", ( ), ( 2,)) # Vis./value promoted
verify_assignable("M_SEL_N_VIS_BOOL", ( ), ( ))
verify_assignable("M_SEL_Y_VIS_TRI", (2,), (1, 2 ))
verify_assignable("M_SEL_M_VIS_TRI", ( ), (1, ))
verify_assignable("M_SEL_N_VIS_TRI", ( ), ( ))
# Symbols implied to y
verify_assignable("Y_IMP_Y_VIS_BOOL", (0, 2), (0, 2))
verify_assignable("Y_IMP_M_VIS_BOOL", ( ), (0, 2)) # Vis. promoted
verify_assignable("Y_IMP_N_VIS_BOOL", ( ), ( ))
verify_assignable("Y_IMP_Y_VIS_TRI", (0, 2), (0, 2)) # m removed by imply
verify_assignable("Y_IMP_M_VIS_TRI", ( ), (0, 2)) # m promoted to y by imply
verify_assignable("Y_IMP_N_VIS_TRI", ( ), ( ))
# Symbols implied to m (never affects assignable values)
verify_assignable("M_IMP_Y_VIS_BOOL", (0, 2), (0, 2))
verify_assignable("M_IMP_M_VIS_BOOL", ( ), (0, 2)) # Vis. promoted
verify_assignable("M_IMP_N_VIS_BOOL", ( ), ( ))
verify_assignable("M_IMP_Y_VIS_TRI", (0, 2), (0, 1, 2))
verify_assignable("M_IMP_M_VIS_TRI", ( ), (0, 1 ))
verify_assignable("M_IMP_N_VIS_TRI", ( ), ( ))
# Symbols in y-mode choice
verify_assignable("Y_CHOICE_BOOL", (2,), (2,))
verify_assignable("Y_CHOICE_TRISTATE", (2,), (2,))
verify_assignable("Y_CHOICE_N_VIS_TRISTATE", ( ), ( ))
# Symbols in m/y-mode choice, starting out in m mode, or y mode when
# running without modules
verify_assignable("MY_CHOICE_BOOL", (2,), ( ))
verify_assignable("MY_CHOICE_TRISTATE", (2,), (0, 1))
verify_assignable("MY_CHOICE_N_VIS_TRISTATE", ( ), ( ))
c.named_choices["MY_CHOICE"].set_value(2)
# Symbols in m/y-mode choice, now in y mode
verify_assignable("MY_CHOICE_BOOL", (2,), (2,))
verify_assignable("MY_CHOICE_TRISTATE", (2,), (2,))
verify_assignable("MY_CHOICE_N_VIS_TRISTATE", ( ), ( ))
def verify_choice_assignable(choice_name, assignable_no_modules,
assignable_modules):
verify_assignable_imp(c.named_choices[choice_name],
assignable_no_modules,
assignable_modules)
# Choices with various possible modes
verify_choice_assignable("Y_CHOICE", (2, ), ( 2,))
verify_choice_assignable("MY_CHOICE", (2, ), ( 1, 2 ))
verify_choice_assignable("NMY_CHOICE", (0, 2), (0, 1, 2 ))
verify_choice_assignable("NY_CHOICE", (0, 2), (0, 2 ))
verify_choice_assignable("NM_CHOICE", ( ), (0, 1 ))
verify_choice_assignable("M_CHOICE", ( ), ( 1, ))
verify_choice_assignable("N_CHOICE", ( ), ( ))
print("Testing object relations")
c = Kconfig("Kconfiglib/tests/Krelation")
verify(c.syms["A"].nodes[0].parent is c.top_node,
"A's parent should be the top node")
verify(c.syms["B"].nodes[0].parent.item is c.named_choices["CHOICE_1"],
"B's parent should be the first choice")
verify(c.syms["C"].nodes[0].parent.item is c.syms["B"],
"C's parent should be B (due to auto menus)")
verify(c.syms["E"].nodes[0].parent.item == MENU,
"E's parent should be a menu")
verify(c.syms["E"].nodes[0].parent.parent is c.top_node,
"E's grandparent should be the top node")
verify(c.syms["G"].nodes[0].parent.item is c.named_choices["CHOICE_2"],
"G's parent should be the second choice")
verify(c.syms["G"].nodes[0].parent.parent.item == MENU,
"G's grandparent should be a menu")
print("Testing hex/int ranges")
c = Kconfig("Kconfiglib/tests/Krange", warn=False)
for sym_name in "HEX_NO_RANGE", "INT_NO_RANGE", "HEX_40", "INT_40":
sym = c.syms[sym_name]
verify(not sym.ranges,
"{} should not have ranges".format(sym_name))
for sym_name in "HEX_ALL_RANGES_DISABLED", "INT_ALL_RANGES_DISABLED", \
"HEX_RANGE_10_20_LOW_DEFAULT", \
"INT_RANGE_10_20_LOW_DEFAULT":
sym = c.syms[sym_name]
verify(sym.ranges, "{} should have ranges".format(sym_name))
# hex/int symbols without defaults should get no default value
verify_value("HEX_NO_RANGE", "")
verify_value("INT_NO_RANGE", "")
# And neither if all ranges are disabled
verify_value("HEX_ALL_RANGES_DISABLED", "")
verify_value("INT_ALL_RANGES_DISABLED", "")
# Make sure they are assignable though, and test that the form of the user
# value is reflected in the value for hex symbols
assign_and_verify("HEX_NO_RANGE", "0x123")
assign_and_verify("HEX_NO_RANGE", "123")
assign_and_verify("INT_NO_RANGE", "123")
# Defaults outside of the valid range should be clamped
verify_value("HEX_RANGE_10_20_LOW_DEFAULT", "0x10")
verify_value("HEX_RANGE_10_20_HIGH_DEFAULT", "0x20")
verify_value("INT_RANGE_10_20_LOW_DEFAULT", "10")
verify_value("INT_RANGE_10_20_HIGH_DEFAULT", "20")
# Defaults inside the valid range should be preserved. For hex symbols,
# they should additionally use the same form as in the assignment.
verify_value("HEX_RANGE_10_20_OK_DEFAULT", "0x15")
verify_value("HEX_RANGE_10_20_OK_DEFAULT_ALTERNATE", "15")
verify_value("INT_RANGE_10_20_OK_DEFAULT", "15")
# hex/int symbols with no defaults but valid ranges should default to the
# lower end of the range if it's > 0
verify_value("HEX_RANGE_10_20", "0x10")
verify_value("HEX_RANGE_0_10", "")
verify_value("INT_RANGE_10_20", "10")
verify_value("INT_RANGE_0_10", "")
verify_value("INT_RANGE_NEG_10_10", "")
# User values and dependent ranges
# Avoid warnings for assigning values outside the active range
c.warn = False
def verify_range(sym_name, low, high, default):
# Verifies that all values in the range 'low'-'high' can be assigned,
# and that assigning values outside the range reverts the value back to
# 'default' (None if it should revert back to "").
is_hex = (c.syms[sym_name].type == HEX)
for i in range(low, high + 1):
assign_and_verify_user_value(sym_name, str(i), str(i), True)
if is_hex:
# The form of the user value should be preserved for hex
# symbols
assign_and_verify_user_value(sym_name, hex(i), hex(i), True)
# Verify that assigning a user value just outside the range causes
# defaults to be used
if default is None:
default_str = ""
else:
default_str = hex(default) if is_hex else str(default)
if is_hex:
too_low_str = hex(low - 1)
too_high_str = hex(high + 1)
else:
too_low_str = str(low - 1)
too_high_str = str(high + 1)
assign_and_verify_value(sym_name, too_low_str, default_str)
assign_and_verify_value(sym_name, too_high_str, default_str)
verify_range("HEX_RANGE_10_20_LOW_DEFAULT", 0x10, 0x20, 0x10)
verify_range("HEX_RANGE_10_20_HIGH_DEFAULT", 0x10, 0x20, 0x20)
verify_range("HEX_RANGE_10_20_OK_DEFAULT", 0x10, 0x20, 0x15)
verify_range("INT_RANGE_10_20_LOW_DEFAULT", 10, 20, 10)
verify_range("INT_RANGE_10_20_HIGH_DEFAULT", 10, 20, 20)
verify_range("INT_RANGE_10_20_OK_DEFAULT", 10, 20, 15)
verify_range("HEX_RANGE_10_20", 0x10, 0x20, 0x10)
verify_range("INT_RANGE_10_20", 10, 20, 10)
verify_range("INT_RANGE_0_10", 0, 10, None)
verify_range("INT_RANGE_NEG_10_10", -10, 10, None)
# Dependent ranges
verify_value("HEX_40", "40")
verify_value("INT_40", "40")
c.syms["HEX_RANGE_10_20"].unset_value()
c.syms["INT_RANGE_10_20"].unset_value()
verify_value("HEX_RANGE_10_40_DEPENDENT", "0x10")
verify_value("INT_RANGE_10_40_DEPENDENT", "10")
c.syms["HEX_RANGE_10_20"].set_value("15")
c.syms["INT_RANGE_10_20"].set_value("15")
verify_value("HEX_RANGE_10_40_DEPENDENT", "0x15")
verify_value("INT_RANGE_10_40_DEPENDENT", "15")
c.unset_values()
verify_range("HEX_RANGE_10_40_DEPENDENT", 0x10, 0x40, 0x10)
verify_range("INT_RANGE_10_40_DEPENDENT", 10, 40, 10)
# Ranges and symbols defined in multiple locations
verify_value("INACTIVE_RANGE", "2")
verify_value("ACTIVE_RANGE", "1")
print("Testing defconfig_filename")
c = Kconfig("Kconfiglib/tests/empty")
verify(c.defconfig_filename is None,
"defconfig_filename should be None with no defconfig_list symbol")
c = Kconfig("Kconfiglib/tests/Kdefconfig_nonexistent")
verify(c.defconfig_filename is None,
"defconfig_filename should be None when none of the files in the "
"defconfig_list symbol exist")
# Referenced in Kdefconfig_existent(_but_n)
os.environ["FOO"] = "defconfig_2"
c = Kconfig("Kconfiglib/tests/Kdefconfig_existent_but_n")
verify(c.defconfig_filename is None,
"defconfig_filename should be None when the condition is n for all "
"the defaults")
c = Kconfig("Kconfiglib/tests/Kdefconfig_existent")
verify(c.defconfig_filename == "Kconfiglib/tests/defconfig_2",
"defconfig_filename should return the existing file "
"Kconfiglib/tests/defconfig_2")
# Should also look relative to $srctree if the specified defconfig is a
# relative path and can't be opened
c = Kconfig("Kconfiglib/tests/Kdefconfig_srctree")
verify(c.defconfig_filename == "Kconfiglib/tests/defconfig_2",
"defconfig_filename gave wrong file with $srctree unset")
os.environ["srctree"] = "Kconfiglib/tests"
c = Kconfig("Kdefconfig_srctree")
verify(c.defconfig_filename == "Kconfiglib/tests/sub/defconfig_in_sub",
"defconfig_filename gave wrong file with $srctree set")
os.environ.pop("srctree", None)
print("Testing mainmenu_text")
c = Kconfig("Kconfiglib/tests/empty")
verify(c.mainmenu_text == "Main menu",
"An empty Kconfig should get a default main menu prompt")
# Expanded in the mainmenu text
os.environ["FOO"] = "bar baz"
c = Kconfig("Kconfiglib/tests/Kmainmenu")
verify(c.mainmenu_text == "---bar baz---",
"Wrong mainmenu text")
print("Testing user_value")
# References undefined env. var. Disable warnings.
c = Kconfig("Kconfiglib/tests/Kmisc", warn=False)
# Avoid warnings from assigning invalid user values and assigning user
# values to symbols without prompts
c.warn = False
syms = [c.syms[name] for name in
("BOOL", "TRISTATE", "STRING", "INT", "HEX")]
for sym in syms:
verify(sym.user_value is None,
"{} should not have a user value to begin with")
# Assign valid values for the types
assign_and_verify_user_value("BOOL", 0, 0, True)
assign_and_verify_user_value("BOOL", 2, 2, True)
assign_and_verify_user_value("TRISTATE", 0, 0, True)
assign_and_verify_user_value("TRISTATE", 1, 1, True)
assign_and_verify_user_value("TRISTATE", 2, 2, True)
assign_and_verify_user_value("STRING", "foo bar", "foo bar", True)
assign_and_verify_user_value("INT", "123", "123", True)
assign_and_verify_user_value("HEX", "0x123", "0x123", True)
# Assign invalid values for the types. They should retain their old user
# value.
assign_and_verify_user_value("BOOL", 1, 2, False)
assign_and_verify_user_value("BOOL", "foo", 2, False)
assign_and_verify_user_value("BOOL", "1", 2, False)
assign_and_verify_user_value("TRISTATE", "foo", 2, False)
assign_and_verify_user_value("TRISTATE", "1", 2, False)
assign_and_verify_user_value("STRING", 0, "foo bar", False)
assign_and_verify_user_value("INT", "foo", "123", False)
assign_and_verify_user_value("INT", 0, "123", False)
assign_and_verify_user_value("HEX", "foo", "0x123", False)
assign_and_verify_user_value("HEX", 0, "0x123", False)
assign_and_verify_user_value("HEX", "-0x1", "0x123", False)
for s in syms:
s.unset_value()
verify(s.user_value is None,
"{} should not have a user value after being reset".
format(s.name))
print("Testing is_menuconfig")
c = Kconfig("Kconfiglib/tests/Kmenuconfig")
for not_menuconfig in c.syms["NOT_MENUCONFIG_1"].nodes[0], \
c.syms["NOT_MENUCONFIG_2"].nodes[0], \
c.syms["MENUCONFIG_MULTI_DEF"].nodes[0], \
c.syms["COMMENT_HOOK"].nodes[0].next:
verify(not not_menuconfig.is_menuconfig,
"'{}' should have is_menuconfig False".format(not_menuconfig))
for menuconfig in c.top_node, \
c.syms["MENUCONFIG_1"].nodes[0], \
c.syms["MENUCONFIG_MULTI_DEF"].nodes[1], \
c.syms["MENU_HOOK"].nodes[0].next, \
c.syms["CHOICE_HOOK"].nodes[0].next:
verify(menuconfig.is_menuconfig,
"'{}' should have is_menuconfig True".format(menuconfig))
print("Testing 'option env' semantics")
os.environ["ENV_VAR"] = "ENV_VAR value"
# References undefined env. var., so disable warnings
c = Kconfig("Kconfiglib/tests/Kmisc", warn=False)
# Verify that 'option env' is treated like a default
verify_value("FROM_ENV", "ENV_VAR value")
verify_value("FROM_ENV_MISSING", "missing")
verify_value("FROM_ENV_WEIRD", "weird")
print("Testing defined vs undefined symbols")
for name in "A", "B", "C", "D", "BOOL", "TRISTATE", "STRING", "INT", "HEX":
verify(c.syms[name].nodes,
"{} should be defined".format(name))
for name in "NOT_DEFINED_1", "NOT_DEFINED_2", "NOT_DEFINED_3", \
"NOT_DEFINED_4":
sym = c.syms[name]
verify(not c.syms[name].nodes,
"{} should not be defined".format(name))
print("Testing Symbol.choice")
for name in "A", "B", "C", "D":
verify(c.syms[name].choice is not None,
"{} should be a choice symbol".format(name))
for name in "Q1", "Q2", "Q3", "BOOL", "TRISTATE", "STRING", "INT", "HEX", \
"FROM_ENV", "FROM_ENV_MISSING", "NOT_DEFINED_1", \
"NOT_DEFINED_2", "NOT_DEFINED_3", "NOT_DEFINED_4":
verify(c.syms[name].choice is None,
"{} should not be a choice symbol".format(name))
print("Testing is_allnoconfig_y")
verify(not c.syms["NOT_ALLNOCONFIG_Y"].is_allnoconfig_y,
"NOT_ALLNOCONFIG_Y should not be allnoconfig_y")
verify(c.syms["ALLNOCONFIG_Y"].is_allnoconfig_y,
"ALLNOCONFIG_Y should be allnoconfig_y")
print("Testing .config reading and writing")
config_test_file = "Kconfiglib/tests/config_test"
def verify_file_contents(fname, contents):
with open(fname, "r") as f:
file_contents = f.read()
verify(file_contents == contents,
"{} contains '{}'. Expected '{}'."
.format(fname, file_contents, contents))
# Writing/reading strings with characters that need to be escaped
c = Kconfig("Kconfiglib/tests/Kescape")
# Test the default value
c.write_config(config_test_file + "_from_def")
verify_file_contents(config_test_file + "_from_def",
r'''CONFIG_STRING="\"\\"''' "\n")
# Write our own value
c.syms["STRING"].set_value(r'''\"a'\\''')
c.write_config(config_test_file + "_from_user")
verify_file_contents(config_test_file + "_from_user",
r'''CONFIG_STRING="\\\"a'\\\\"''' "\n")
# Read back the two configs and verify the respective values
c.load_config(config_test_file + "_from_def")
verify_value("STRING", '"\\')
c.load_config(config_test_file + "_from_user")
verify_value("STRING", r'''\"a'\\''')
# Appending values from a .config
c = Kconfig("Kconfiglib/tests/Kappend")
# Values before assigning
verify_value("BOOL", "n")
verify_value("STRING", "")
# Assign BOOL
c.load_config("Kconfiglib/tests/config_set_bool", replace=False)
verify_value("BOOL", "y")
verify_value("STRING", "")
# Assign STRING
c.load_config("Kconfiglib/tests/config_set_string", replace=False)
verify_value("BOOL", "y")
verify_value("STRING", "foo bar")
# Reset BOOL
c.load_config("Kconfiglib/tests/config_set_string")
verify_value("BOOL", "n")
verify_value("STRING", "foo bar")
# Loading a completely empty .config should reset values
c.load_config("Kconfiglib/tests/empty")
verify_value("STRING", "")
# An indented assignment in a .config should be ignored
c.load_config("Kconfiglib/tests/config_indented")
verify_value("IGNOREME", "y")
# Symbol order in headers and minimal configuration files should match
# definition order, like in .config files
c = Kconfig("Kconfiglib/tests/Korder")
c.write_autoconf(config_test_file)
verify_file_contents(config_test_file, """
#define CONFIG_O 0
#define CONFIG_R 1
#define CONFIG_D 2
#define CONFIG_E 3
#define CONFIG_R2 4
#define CONFIG_I 5
#define CONFIG_N 6
#define CONFIG_G 7
"""[1:])
# Differs from defaults
c.syms["O"].set_value("-1")
c.syms["R"].set_value("-1")
c.syms["E"].set_value("-1")
c.syms["R2"].set_value("-1")
c.syms["N"].set_value("-1")
c.syms["G"].set_value("-1")
c.write_min_config(config_test_file)
verify_file_contents(config_test_file, """
CONFIG_O=-1
CONFIG_R=-1
CONFIG_E=-1
CONFIG_R2=-1
CONFIG_N=-1
CONFIG_G=-1
"""[1:])
# Test header strings in configuration files and headers
os.environ["KCONFIG_CONFIG_HEADER"] = "config header from env.\n"
os.environ["KCONFIG_AUTOHEADER_HEADER"] = "header header from env.\n"
c = Kconfig("Kconfiglib/tests/Kheader")
c.write_config(config_test_file, header="config header from param\n")
verify_file_contents(config_test_file, """\
config header from param
CONFIG_FOO=y
""")
c.write_min_config(config_test_file, header="min. config header from param\n")
verify_file_contents(config_test_file, """\
min. config header from param
""")
c.write_config(config_test_file)
verify_file_contents(config_test_file, """\
config header from env.
CONFIG_FOO=y
""")
c.write_min_config(config_test_file)
verify_file_contents(config_test_file, """\
config header from env.
""")
c.write_autoconf(config_test_file, header="header header from param\n")
verify_file_contents(config_test_file, """\
header header from param
#define CONFIG_FOO 1
""")
c.write_autoconf(config_test_file)
verify_file_contents(config_test_file, """\
header header from env.
#define CONFIG_FOO 1
""")
del os.environ["KCONFIG_CONFIG_HEADER"]
del os.environ["KCONFIG_AUTOHEADER_HEADER"]
print("Testing Kconfig fetching and separation")
for c in Kconfig("Kconfiglib/tests/Kmisc", warn=False), \
Kconfig("Kconfiglib/tests/Kmisc", warn=False):
for item in c.syms["BOOL"], \
c.syms["BOOL"].nodes[0], \
c.named_choices["OPTIONAL"], \
c.named_choices["OPTIONAL"].nodes[0], \
c.syms["MENU_HOOK"].nodes[0].next, \
c.syms["COMMENT_HOOK"].nodes[0].next:
verify(item.kconfig is c,
".kconfig not properly set for " + repr(item))
print("Testing imply semantics")
c = Kconfig("Kconfiglib/tests/Kimply")
verify_value("IMPLY_DIRECT_DEPS", "y")
verify_value("UNMET_DIRECT_1", "n")
verify_value("UNMET_DIRECT_2", "n")
verify_value("UNMET_DIRECT_3", "n")
verify_value("MET_DIRECT_1", "y")
verify_value("MET_DIRECT_2", "y")
verify_value("MET_DIRECT_3", "y")
verify_value("MET_DIRECT_4", "y")
verify_value("IMPLY_COND", "y")
verify_value("IMPLIED_N_COND", "n")
verify_value("IMPLIED_M_COND", "m")
verify_value("IMPLIED_Y_COND", "y")
verify_value("IMPLY_N_1", "n")
verify_value("IMPLY_N_2", "n")
verify_value("IMPLIED_FROM_N_1", "n")
verify_value("IMPLIED_FROM_N_2", "n")
verify_value("IMPLY_M", "m")
verify_value("IMPLIED_M", "m")
verify_value("IMPLIED_M_BOOL", "y")
verify_value("IMPLY_M_TO_Y", "y")
verify_value("IMPLIED_M_TO_Y", "y")
# Test user value semantics
# Verify that IMPLIED_TRISTATE is invalidated if the direct
# dependencies change
assign_and_verify("IMPLY", 2)
assign_and_verify("DIRECT_DEP", 2)
verify_value("IMPLIED_TRISTATE", 2)
assign_and_verify("DIRECT_DEP", 0)
verify_value("IMPLIED_TRISTATE", 0)
# Set back for later tests
assign_and_verify("DIRECT_DEP", 2)
# Verify that IMPLIED_TRISTATE can be set to anything when IMPLY has value
# n, and that it gets the value n by default (for non-imply-related
# reasons)
assign_and_verify("IMPLY", 0)
assign_and_verify("IMPLIED_TRISTATE", 0)
assign_and_verify("IMPLIED_TRISTATE", 1)
assign_and_verify("IMPLIED_TRISTATE", 2)
c.syms["IMPLIED_TRISTATE"].unset_value()
verify_value("IMPLIED_TRISTATE", "n")
# Same as above for m. Anything still goes, but m by default now.
assign_and_verify("IMPLY", 1)
assign_and_verify("IMPLIED_TRISTATE", 0)
assign_and_verify("IMPLIED_TRISTATE", 1)
assign_and_verify("IMPLIED_TRISTATE", 2)
c.syms["IMPLIED_TRISTATE"].unset_value()
verify_value("IMPLIED_TRISTATE", 1)
# Same as above for y. Only n and y should be accepted. m gets promoted to
# y. Default should be y.
assign_and_verify("IMPLY", 2)
assign_and_verify("IMPLIED_TRISTATE", 0)
assign_and_verify_value("IMPLIED_TRISTATE", 1, 2)
assign_and_verify("IMPLIED_TRISTATE", 2)
c.syms["IMPLIED_TRISTATE"].unset_value()
verify_value("IMPLIED_TRISTATE", 2)
# Being implied to either m or y should give a bool the value y
c.syms["IMPLY"].unset_value()
verify_value("IMPLIED_BOOL", 0)
assign_and_verify("IMPLY", 0)
verify_value("IMPLIED_BOOL", 0)
assign_and_verify("IMPLY", 1)
verify_value("IMPLIED_BOOL", 2)
assign_and_verify("IMPLY", 2)
verify_value("IMPLIED_BOOL", 2)
# A bool implied to m or y can take the values n and y
c.syms["IMPLY"].set_value(1)
assign_and_verify("IMPLIED_BOOL", 0)
assign_and_verify("IMPLIED_BOOL", 2)
c.syms["IMPLY"].set_value(2)
assign_and_verify("IMPLIED_BOOL", 0)
assign_and_verify("IMPLIED_BOOL", 2)
print("Testing choice semantics")
# Would warn for choice value symbols defined without a type, even
# though the type is automatically derived. This is probably more
# helpful than ignoring those cases, as this feature isn't used
# deliberately anywhere from what I've seen.
c = Kconfig("Kconfiglib/tests/Kchoice", warn=False)
for name in "BOOL", "BOOL_OPT", "BOOL_M", "DEFAULTS":
verify(c.named_choices[name].orig_type == BOOL,
"choice {} should have type bool".format(name))
for name in "TRISTATE", "TRISTATE_OPT", "TRISTATE_M":
verify(c.named_choices[name].orig_type == TRISTATE,
"choice {} should have type tristate".format(name))
def select_and_verify(sym):
choice = sym.nodes[0].parent.item
choice.set_value(2)
sym.set_value(2)
verify(sym.choice.selection is sym,
sym.name + " should be the selected symbol")
verify(choice.user_selection is sym,
sym.name + " should be the user selection of the choice")
verify(sym.tri_value == 2,
sym.name + " should have value y when selected")
verify(sym.user_value == 2,
sym.name + " should have user value y when selected")
for sibling in choice.syms:
if sibling is not sym:
verify(sibling.tri_value == 0,
sibling.name + " should be n when not selected")
def select_and_verify_all(choice_name):
choice = c.named_choices[choice_name]
# Select in forward order
for sym in choice.syms:
select_and_verify(sym)
# Select in reverse order
for sym in reversed(choice.syms):
select_and_verify(sym)
def verify_mode(choice_name, no_modules_mode, modules_mode):
choice = c.named_choices[choice_name]
c.modules.set_value(0)
verify(choice.tri_value == no_modules_mode,
'Wrong mode for choice {} with no modules. Expected {}, got {}.'
.format(choice.name, no_modules_mode, choice.tri_value))
c.modules.set_value(2)
verify(choice.tri_value == modules_mode,
'Wrong mode for choice {} with modules. Expected {}, got {}.'
.format(choice.name, modules_mode, choice.tri_value))
verify_mode("BOOL", 2, 2)
verify_mode("BOOL_OPT", 0, 0)
verify_mode("TRISTATE", 2, 1)
verify_mode("TRISTATE_OPT", 0, 0)
verify_mode("BOOL_M", 0, 2)
verify_mode("TRISTATE_M", 0, 1)
# Test defaults
choice = c.named_choices["DEFAULTS"]
c.syms["TRISTATE_SYM"].set_value(0)
verify(choice.selection is c.syms["OPT_4"],
"Wrong choice default with TRISTATE_SYM = n")
c.syms["TRISTATE_SYM"].set_value(2)
verify(choice.selection is c.syms["OPT_2"],
"Wrong choice default with TRISTATE_SYM = y")
c.syms["OPT_1"].set_value(2)
verify(choice.selection is c.syms["OPT_1"],
"User selection should override defaults")
verify(c.named_choices["DEFAULTS_NOT_VISIBLE"].selection
is c.syms["OPT_8"],
"Non-visible choice symbols should cause the next default to be "
"considered")
# Test y mode selection
c.modules.set_value(2)
select_and_verify_all("BOOL")
select_and_verify_all("BOOL_OPT")
select_and_verify_all("TRISTATE")
select_and_verify_all("TRISTATE_OPT")
# For BOOL_M, the mode should have been promoted
select_and_verify_all("BOOL_M")
# Test m mode selection
c.named_choices["TRISTATE"].set_value(1)
verify(c.named_choices["TRISTATE"].tri_value == 1,
"TRISTATE choice should have mode m after explicit mode assignment")
assign_and_verify_value("T_1", 0, 0)
assign_and_verify_value("T_2", 0, 0)
assign_and_verify_value("T_1", 1, 1)
assign_and_verify_value("T_2", 1, 1)
assign_and_verify_value("T_1", 2, 1)
assign_and_verify_value("T_2", 2, 1)
# Switching to y mode should cause T_2 to become selected
c.named_choices["TRISTATE"].set_value(2)
verify_value("T_1", 0)
verify_value("T_2", 2)
# Verify that choices with no explicitly specified type get the type of the
# first contained symbol with a type
verify(c.named_choices["NO_TYPE_BOOL"].orig_type == BOOL,
"Expected first choice without explicit type to have type bool")
verify(c.named_choices["NO_TYPE_TRISTATE"].orig_type == TRISTATE,
"Expected second choice without explicit type to have type "
"tristate")
# Verify that symbols without a type in the choice get the type of the
# choice
for name in "MMT_1", "MMT_2", "MMT_4", "MMT_5":
verify(c.syms[name].orig_type == BOOL,
"Expected {} to get type bool".format(name))
verify(c.syms["MMT_3"].orig_type == TRISTATE,
"Expected MMT_3 to have type tristate")
# Verify that the default selection can change depending on the
# visibility of the choice symbols
default_with_dep_choice = c.named_choices["DEFAULT_WITH_DEP"]
verify(default_with_dep_choice.selection is c.syms["B"],
"Wrong choice default with unsatisfied deps on default")
c.syms["DEP"].set_value("y")
verify(default_with_dep_choice.selection is c.syms["A"],
"Wrong choice default with satisfied deps on default")
c.syms["DEP"].set_value("n")
verify(default_with_dep_choice.selection is c.syms["B"],
"Wrong choice default with unsatisfied deps on default (round two)")
# Verify that symbols in choices that depend on the preceding symbol aren't
# considered choice symbols
weird_choice = c.named_choices["WEIRD_SYMS"]
def verify_is_normal_choice_symbol(name):
sym = c.syms[name]
verify(sym.choice is not None and
sym in weird_choice.syms and
sym.nodes[0].parent.item is weird_choice,
"{} should be a normal choice symbol".format(sym.name))
def verify_is_weird_choice_symbol(name):
sym = c.syms[name]
verify(sym.choice is None and
sym not in weird_choice.syms,
"{} should be a weird (non-)choice symbol"
.format(sym.name))
verify_is_normal_choice_symbol("WS1")
verify_is_weird_choice_symbol("WS2")
verify_is_weird_choice_symbol("WS3")
verify_is_weird_choice_symbol("WS4")
verify_is_weird_choice_symbol("WS5")
verify_is_normal_choice_symbol("WS6")
verify_is_weird_choice_symbol("WS7")
verify_is_weird_choice_symbol("WS8")
verify_is_normal_choice_symbol("WS9")
print("Testing 'if' node removal")
c = Kconfig("Kconfiglib/tests/Kifremoval", warn=False)
nodes = tuple(c.node_iter())
verify_equal(nodes[0].item.name, "A")
verify_equal(nodes[1].item.name, "B")
verify_equal(nodes[2].item.name, "C")
verify_equal(nodes[3].item.name, "D")
verify_equal(nodes[4].prompt[0], "E")
verify_equal(nodes[5].prompt[0], "F")
verify_equal(nodes[6].prompt[0], "G")
verify_equal(nodes[7].item.name, "H")
verify_equal(nodes[8].item.name, "I")
verify_equal(nodes[9].item.name, "J")
verify(len(nodes) == 10,
"Wrong number of nodes after 'if' removal")
print("Testing multi.def. property copying")
c = Kconfig("Kconfiglib/tests/Kdepcopy", warn=False)
def verify_props(desc, props, prop_names):
actual = [prop[0].name for prop in props]
expected = prop_names.split()
verify(actual == expected,
"Wrong {} properties, expected '{}', got '{}'"
.format(desc, expected, actual))
verify_props("default", c.syms["MULTIDEF"].defaults,
"A B C D E F G H I J K L M N O P Q R")
verify_props("select", c.syms["MULTIDEF"].selects,
"AA BB CC DD EE FF GG HH II JJ")
verify_props("imply", c.syms["MULTIDEF"].selects,
"AA BB CC DD EE FF GG HH II JJ")
verify_props("select", c.syms["MULTIDEF_CHOICE"].selects,
"A B C")
verify_props("range", c.syms["MULTIDEF_RANGE"].ranges,
"A B C D E F")
verify_props("default", c.choices[1].defaults,
"A B C D E")
print("Testing dependency loop detection")
# These are all expected to raise dependency loop errors
for i in range(11):
filename = "Kconfiglib/tests/Kdeploop" + str(i)
try:
Kconfig(filename)
except KconfigError as e:
if "Dependency loop" not in str(e):
fail("dependency loop in {} raised wrong KconfigError"
.format(filename))
except:
fail("dependency loop in {} raised wrong exception"
.format(filename))
else:
fail("dependency loop in {} not detected".format(filename))
# Check the most complicated message completely
try:
Kconfig("Kconfiglib/tests/Kdeploop10")
except KconfigError as e:
verify_equal(str(e), """
Dependency loop
===============
A (defined at Kconfiglib/tests/Kdeploop10:1), with definition...
config A
bool
depends on B
...depends on B (defined at Kconfiglib/tests/Kdeploop10:5), with definition...
config B
bool
depends on C = 7
...depends on C (defined at Kconfiglib/tests/Kdeploop10:9), with definition...
config C
int
range D 8
...depends on D (defined at Kconfiglib/tests/Kdeploop10:13), with definition...
config D
int
default 3 if E
default 8
...depends on E (defined at Kconfiglib/tests/Kdeploop10:18), with definition...
config E
bool
(select-related dependencies: F && G)
...depends on G (defined at Kconfiglib/tests/Kdeploop10:25), with definition...
config G
bool
depends on H
...depends on the choice symbol H (defined at Kconfiglib/tests/Kdeploop10:32), with definition...
config H
bool "H"
depends on I && <choice>
...depends on the choice symbol I (defined at Kconfiglib/tests/Kdeploop10:41), with definition...
config I
bool "I"
depends on <choice>
...depends on <choice> (defined at Kconfiglib/tests/Kdeploop10:38), with definition...
choice
bool "choice" if J
...depends on J (defined at Kconfiglib/tests/Kdeploop10:46), with definition...
config J
bool
depends on A
...depends again on A (defined at Kconfiglib/tests/Kdeploop10:1)
"""[:-1])
except:
fail("Loop detection message check raised wrong exception")
else:
fail("Loop detection message check did not raise exception")
print("Testing preprocessor")
os.environ["ENV_1"] = "env_1"
os.environ["ENV_2"] = "env_2"
os.environ["ENV_3"] = "env_3"
os.environ["ENV_4"] = "env_4"
os.environ["ENV_5"] = "n"
os.environ["ENV_6"] = "Kconfiglib/tests/empty"
os.environ["ENV_7"] = "env_7"
# We verify warnings manually
c = Kconfig("Kconfiglib/tests/Kpreprocess", warn_to_stderr=False)
def verify_variable(name, unexp_value, exp_value, recursive, *args):
var = c.variables[name]
verify(var.value == unexp_value,
"expected variable '{}' to have the unexpanded value '{}', had "
"the value '{}'".format(name, unexp_value, var.value))
if not args:
verify(var.expanded_value == exp_value,
"expected expanded_value for {} to be '{}', was '{}'"
.format(name, exp_value, var.expanded_value))
verify(var.expanded_value_w_args(*args) == exp_value,
"expected expanded_value_w_args() for '{}' to be '{}', was '{}'"
.format(name, exp_value, var.expanded_value_w_args(*args)))
verify(var.is_recursive == recursive,
"{} was {}, shouldn't be"
.format(name, "recursive" if var.is_recursive else "simple"))
verify_variable("simple-recursive", "foo", "foo", True)
verify_variable("simple-immediate", "bar", "bar", False)
verify_variable("simple-recursive-2", "baz", "baz", True)
verify_variable("whitespaced", "foo", "foo", True)
verify_variable("preserve-recursive", "foo bar", "foo bar", True)
verify_variable("preserve-immediate", "foo bar", "foo bar", False)
verify_variable("recursive",
"$(foo) $(bar) $($(b-char)a$(z-char)) $(indir)",
"abc def ghi jkl mno",
True)
verify_variable("immediate", "foofoo", "foofoo", False)
verify_variable("messy-fn-res",
"$($(fn-indir)-unused-arg, a b (,) , c d )",
'surround-rev-quote " c d " " a b (,) " surround-rev-quote ',
True)
verify_variable("special-chars-fn-res",
"$(fn,$(comma)$(dollar)$(left-paren)foo$(right-paren))",
'",$(foo)"',
True)
verify_variable("quote", '"$(1)" "$(2)"', '"" ""', True)
verify_variable("quote", '"$(1)" "$(2)"', '"one" ""', True,
"one")
verify_variable("quote", '"$(1)" "$(2)"', '"one" "two"', True,
"one", "two")
verify_variable("quote", '"$(1)" "$(2)"', '"one" "two"', True,
"one", "two", "three")
verify_str(c.syms["PRINT_ME"], r"""
config PRINT_ME
string "env_1" if (FOO && BAR) || !BAZ || !QAZ
default "\"foo\"" if "foo \"bar\" baz" = ""
""")
verify_str(c.syms["PRINT_ME_TOO"], r"""
config PRINT_ME_TOO
bool "foo"
default FOOBARBAZQAZ if QAZ && QAZFOO && xxx
""")
def verify_repr(name, s):
verify_equal(repr(c.variables[name]), s)
verify_repr(
"simple-immediate",
"<variable simple-immediate, immediate, value 'bar'>")
verify_repr(
"messy-fn-res",
"<variable messy-fn-res, recursive, value '$($(fn-indir)-unused-arg, a b (,) , c d )'>")
def verify_recursive(name):
try:
c.variables[name].expanded_value
except KconfigError:
pass
else:
fail("Expected '{}' expansion to flag recursive expansion, didn't"
.format(name))
verify_recursive("rec-1")
# Indirectly verifies that it's not recursive
verify_variable("safe-fn-rec-res",
"$(safe-fn-rec,safe-fn-rec-2)",
"foo",
True)
verify_recursive("unsafe-fn-rec")
verify_variable("foo-bar-baz", "$(rhs)", "value", True)
verify_variable("space-var-res", "$(foo bar)", "value", True)
verify_variable("shell-res",
"$(shell,false && echo foo bar || echo baz qaz)",
"baz qaz",
True)
verify_variable("shell-stderr-res", "", "", False)
verify_variable("parens-res",
"pre-$(shell,echo '(a,$(b-char),(c,d),e)')-post",
"pre-(a,b,(c,d),e)-post",
True)
verify_variable("location-res",
"Kconfiglib/tests/Kpreprocess:129",
"Kconfiglib/tests/Kpreprocess:129",
False)
verify_variable("warning-res", "", "", False)
verify_variable("error-n-res", "", "", False)
try:
c.variables["error-y-res"].expanded_value
except KconfigError:
pass
else:
fail("expanding error-y-res didn't raise an exception")
# Check Kconfig.env_vars
verify_equal(c.env_vars,
set(("ENV_1", "ENV_2", "ENV_3", "ENV_4", "ENV_5", "ENV_6")))
# Check that the expected warnings were generated
verify_equal(c.warnings, [
"Kconfiglib/tests/Kpreprocess:122: warning: 'echo message on stderr >&2' wrote to stderr: message on stderr",
"Kconfiglib/tests/Kpreprocess:134: warning: a warning"
])
print("Testing user-defined preprocessor functions")
# Make Kconfiglib/tests/kconfigfunctions.py importable
sys.path.insert(0, "Kconfiglib/tests")
c = Kconfig("Kconfiglib/tests/Kuserfunctions")
verify_variable("add-zero", "$(add)", "0", True)
verify_variable("add-one", "$(add,1)", "1", True)
verify_variable("add-three", "$(add,1,-1,2,1)", "3", True)
verify_variable("one-one", "$(one,foo bar)", "onefoo barfoo bar", True)
verify_variable("one-or-more-one", "$(one-or-more,foo)", "foo + ", True)
verify_variable("one-or-more-three", "$(one-or-more,foo,bar,baz)",
"foo + bar,baz", True)
verify_variable("location-1", "Kconfiglib/tests/Kuserfunctions:13",
"Kconfiglib/tests/Kuserfunctions:13", False)
verify_variable("location-2", "Kconfiglib/tests/Kuserfunctions:14",
"Kconfiglib/tests/Kuserfunctions:14", False)
def verify_bad_argno(name):
try:
c.variables[name].expanded_value
except KconfigError:
pass
else:
fail("Expected '{}' expansion to flag wrong number of arguments, "
"didn't".format(name))
verify_bad_argno("one-zero")
verify_bad_argno("one-two")
verify_bad_argno("one-or-more-zero")
sys.path.pop(0)
# This test can fail on older Python 3.x versions, because they don't
# preserve dict insertion order during iteration. The output is still
# correct, just different.
if not (3, 0) <= sys.version_info <= (3, 5):
print("Testing KCONFIG_WARN_UNDEF")
os.environ["KCONFIG_WARN_UNDEF"] = "y"
c = Kconfig("Kconfiglib/tests/Kundef", warn_to_stderr=False)
verify_equal("\n".join(c.warnings), """
warning: the int symbol INT (defined at Kconfiglib/tests/Kundef:8) has a non-int range [UNDEF_2 (undefined), 8 (undefined)]
warning: undefined symbol UNDEF_1:
- Referenced at Kconfiglib/tests/Kundef:4:
config BOOL
bool "foo" if DEF || !UNDEF_1
default UNDEF_2
- Referenced at Kconfiglib/tests/Kundef:19:
menu "menu"
depends on UNDEF_1
visible if UNDEF_3
warning: undefined symbol UNDEF_2:
- Referenced at Kconfiglib/tests/Kundef:4:
config BOOL
bool "foo" if DEF || !UNDEF_1
default UNDEF_2
- Referenced at Kconfiglib/tests/Kundef:8:
config INT
int
range UNDEF_2 8
range 5 15
default 10
warning: undefined symbol UNDEF_3:
- Referenced at Kconfiglib/tests/Kundef:19:
menu "menu"
depends on UNDEF_1
visible if UNDEF_3
"""[1:-1])
os.environ.pop("KCONFIG_WARN_UNDEF")
print("\nAll selftests passed\n" if all_passed else
"\nSome selftests failed\n")
def run_compatibility_tests():
# Runs tests on configurations from the kernel. Tests compability with the
# C implementation by comparing outputs.
# Referenced inside the kernel Kconfig files.
#
# The str() makes the type of the value 'str' on both Python 2 and Python 3,
# which is nice for some later dictionary key sanity checks.
os.environ["KERNELVERSION"] = str(
subprocess.check_output("make kernelversion", shell=True)
.decode("utf-8").rstrip()
)
os.environ["CC_VERSION_TEXT"] = str(
subprocess.check_output("gcc --version | head -n1", shell=True)
.decode("utf-8").rstrip()
)
os.environ["srctree"] = "."
os.environ["CC"] = "gcc"
os.environ["LD"] = "ld"
if not os.path.exists("scripts/kconfig/conf"):
print("\nscripts/kconfig/conf does not exist -- running "
"'make allnoconfig' to build it...")
shell("make allnoconfig")
print("Running compatibility tests...\n")
test_fns = (test_defconfig,
# Fails for a few defconfigs due to a bug in the C tools. Will
# be enabled once patches get in.
#test_min_config,
test_alldefconfig,
test_allnoconfig,
test_allnoconfig_walk,
test_allmodconfig,
test_allyesconfig,
test_sanity)
for test_fn in test_fns:
# The test description is taken from the docstring of the corresponding
# function
print(textwrap.dedent(test_fn.__doc__))
for arch, srcarch in all_arch_srcarch():
# Referenced inside the Kconfig files
os.environ["ARCH"] = arch
os.environ["SRCARCH"] = srcarch
rm_configs()
test_fn(arch, srcarch)
if all_passed:
print("All selftests and compatibility tests passed")
else:
sys.exit("Some tests failed")
def all_arch_srcarch():
for srcarch in os.listdir("arch"):
# arc and h8300 are currently broken with the C tools on linux-next as
# well. Perhaps they require cross-compilers to be installed.
#
# User-mode Linux has an unorthodox Kconfig setup that would require a
# different testing setup. Skip it too.
if srcarch in ("arc", "h8300", "um"):
continue
if os.path.exists(os.path.join("arch", srcarch, "Kconfig")):
yield (srcarch, srcarch)
# Some arches define additional ARCH settings with ARCH != SRCARCH
# (search for "Additional ARCH settings for" in the top-level Makefile)
yield ("i386", "x86")
yield ("x86_64", "x86")
yield ("sparc32", "sparc")
yield ("sparc64", "sparc")
yield ("sh64", "sh")
def test_allnoconfig(arch, srcarch):
"""
Verify that allnoconfig.py generates the same .config as
'make allnoconfig', for each architecture. Runs the script via
'make scriptconfig'.
"""
shell("make scriptconfig SCRIPT=Kconfiglib/allnoconfig.py "
"PYTHONCMD='{}'".format(sys.executable))
shell("mv .config ._config")
shell("scripts/kconfig/conf --allnoconfig Kconfig")
compare_configs(arch)
def test_allnoconfig_walk(arch, srcarch):
"""
Verify that examples/allnoconfig_walk.py generates the same .config as
'make allnoconfig', for each architecture. Runs the script via
'make scriptconfig'.
"""
shell("make scriptconfig SCRIPT=Kconfiglib/examples/allnoconfig_walk.py "
"PYTHONCMD='{}'".format(sys.executable))
shell("mv .config ._config")
shell("scripts/kconfig/conf --allnoconfig Kconfig")
compare_configs(arch)
def test_allmodconfig(arch, srcarch):
"""
Verify that allmodconfig.py generates the same .config as
'make allmodconfig', for each architecture. Runs the script via
'make scriptconfig'.
"""
shell("make scriptconfig SCRIPT=Kconfiglib/allmodconfig.py "
"PYTHONCMD='{}'".format(sys.executable))
shell("mv .config ._config")
shell("scripts/kconfig/conf --allmodconfig Kconfig")
compare_configs(arch)
def test_allyesconfig(arch, srcarch):
"""
Verify that allyesconfig.py generates the same .config as
'make allyesconfig', for each architecture. Runs the script via
'make scriptconfig'.
"""
shell("make scriptconfig SCRIPT=Kconfiglib/allyesconfig.py "
"PYTHONCMD='{}'".format(sys.executable))
shell("mv .config ._config")
shell("scripts/kconfig/conf --allyesconfig Kconfig")
compare_configs(arch)
def test_sanity(arch, srcarch):
"""
Do sanity checks on each configuration and call all public methods on all
symbols, choices, and menu nodes for all architectures to make sure we
never crash or hang.
"""
print("For {}...".format(arch))
kconf = Kconfig()
for sym in kconf.defined_syms:
verify(sym._visited == 2,
"{} has broken dependency loop detection (_visited = {})"
.format(sym.name, sym._visited))
kconf.modules
kconf.defconfig_list
kconf.defconfig_filename
# Legacy warning functions
kconf.enable_redun_warnings()
kconf.disable_redun_warnings()
kconf.enable_undef_warnings()
kconf.disable_undef_warnings()
kconf.enable_warnings()
kconf.disable_warnings()
kconf.enable_stderr_warnings()
kconf.disable_stderr_warnings()
kconf.mainmenu_text
kconf.unset_values()
kconf.write_autoconf("/dev/null")
# No tempfile.TemporaryDirectory in Python 2
tmpdir = tempfile.mkdtemp()
kconf.sync_deps(os.path.join(tmpdir, "deps")) # Create
kconf.sync_deps(os.path.join(tmpdir, "deps")) # Update
shutil.rmtree(tmpdir)
# Python 2/3 compatible
for key, sym in kconf.syms.items():
verify(isinstance(key, str), "weird key '{}' in syms dict".format(key))
verify(not sym.is_constant, sym.name + " in 'syms' and constant")
verify(sym not in kconf.const_syms,
sym.name + " in both 'syms' and 'const_syms'")
for dep in sym._dependents:
verify(not dep.is_constant,
"the constant symbol {} depends on {}"
.format(dep.name, sym.name))
sym.__repr__()
sym.__str__()
sym.assignable
kconf.disable_warnings()
sym.set_value(2)
sym.set_value("foo")
sym.unset_value()
kconf.enable_warnings() # Legacy warning function
sym.str_value
sym.tri_value
sym.type
sym.user_value
sym.visibility
for sym in kconf.defined_syms:
verify(sym.nodes, sym.name + " is defined but lacks menu nodes")
verify(not (sym.orig_type not in (BOOL, TRISTATE) and sym.choice),
sym.name + " is a choice symbol but not bool/tristate")
for key, sym in kconf.const_syms.items():
verify(isinstance(key, str),
"weird key '{}' in const_syms dict".format(key))
verify(sym.is_constant,
'"{}" is in const_syms but not marked constant'
.format(sym.name))
verify(not sym.nodes,
'"{}" is constant but has menu nodes'.format(sym.name))
verify(not sym._dependents,
'"{}" is constant but is a dependency of some symbol'
.format(sym.name))
verify(not sym.choice,
'"{}" is constant and a choice symbol'.format(sym.name))
sym.__repr__()
sym.__str__()
sym.assignable
kconf.disable_warnings()
sym.set_value(2)
sym.set_value("foo")
sym.unset_value()
kconf.enable_warnings() # Legacy warning function
sym.str_value
sym.tri_value
sym.type
sym.visibility
for choice in kconf.choices:
for sym in choice.syms:
verify(sym.choice is choice,
"{0} is in choice.syms but 'sym.choice' is not the choice"
.format(sym.name))
verify(sym.type in (BOOL, TRISTATE),
"{} is a choice symbol but is not a bool/tristate"
.format(sym.name))
choice.__str__()
choice.__repr__()
choice.str_value
choice.tri_value
choice.user_value
choice.assignable
choice.selection
choice.type
choice.visibility
# Menu nodes
node = kconf.top_node
while 1:
# Everything else should be well exercised elsewhere
node.__repr__()
node.__str__()
verify(isinstance(node.item, (Symbol, Choice)) or \
node.item in (MENU, COMMENT),
"'{}' appeared as a menu item".format(node.item))
if node.list is not None:
node = node.list
elif node.next is not None:
node = node.next
else:
while node.parent is not None:
node = node.parent
if node.next is not None:
node = node.next
break
else:
break
def test_alldefconfig(arch, srcarch):
"""
Verify that alldefconfig.py generates the same .config as
'make alldefconfig', for each architecture. Runs the script via
'make scriptconfig'.
"""
shell("make scriptconfig SCRIPT=Kconfiglib/alldefconfig.py "
"PYTHONCMD='{}'".format(sys.executable))
shell("mv .config ._config")
shell("scripts/kconfig/conf --alldefconfig Kconfig")
compare_configs(arch)
def test_defconfig(arch, srcarch):
"""
Verify that Kconfiglib generates the same .config as scripts/kconfig/conf,
for each architecture/defconfig pair. In obsessive mode, this test includes
nonsensical groupings of arches with defconfigs from other arches (every
arch/defconfig combination) and takes an order of magnitude longer time to
run.
With logging enabled, this test appends any failures to a file
test_defconfig_fails in the root.
"""
kconf = Kconfig()
if obsessive:
defconfigs = []
# Collect all defconfigs. This could be done once instead, but it's
# a speedy operation comparatively.
for srcarch_ in os.listdir("arch"):
defconfigs.extend(defconfig_files(srcarch_))
else:
defconfigs = defconfig_files(srcarch)
# Test architecture for each defconfig
for defconfig in defconfigs:
rm_configs()
kconf.load_config(defconfig)
kconf.write_config("._config")
shell("scripts/kconfig/conf --defconfig='{}' Kconfig".
format(defconfig))
arch_defconfig_str = " {:14}with {:60} ".format(arch, defconfig)
if equal_configs():
print(arch_defconfig_str + "OK")
else:
print(arch_defconfig_str + "FAIL")
fail()
if log:
with open("test_defconfig_fails", "a") as fail_log:
fail_log.write("{} with {} did not match\n"
.format(arch, defconfig))
def test_min_config(arch, srcarch):
"""
Verify that Kconfiglib generates the same .config as 'make savedefconfig'
for each architecture/defconfig pair.
"""
kconf = Kconfig()
if obsessive_min_config:
defconfigs = []
for srcarch_ in os.listdir("arch"):
defconfigs.extend(defconfig_files(srcarch_))
else:
defconfigs = defconfig_files(srcarch)
for defconfig in defconfigs:
rm_configs()
kconf.load_config(defconfig)
kconf.write_min_config("._config")
shell("cp {} .config".format(defconfig))
shell("scripts/kconfig/conf --savedefconfig=.config Kconfig")
arch_defconfig_str = " {:14}with {:60} ".format(arch, defconfig)
if equal_configs():
print(arch_defconfig_str + "OK")
else:
print(arch_defconfig_str + "FAIL")
#
# Helper functions
#
def defconfig_files(srcarch):
# Yields a list of defconfig file filenames for a particular srcarch
# subdirectory (arch/<srcarch>/)
srcarch_dir = os.path.join("arch", srcarch)
# Some arches have a defconfig in the root of their arch/<arch>/ directory
root_defconfig = os.path.join(srcarch_dir, "defconfig")
if os.path.exists(root_defconfig):
yield root_defconfig
# Assume all files in the arch/<arch>/configs/ directory (if it exists) are
# configurations
defconfigs_dir = os.path.join(srcarch_dir, "configs")
if not os.path.isdir(defconfigs_dir):
return
for dirpath, _, filenames in os.walk(defconfigs_dir):
for filename in filenames:
yield os.path.join(dirpath, filename)
def rm_configs():
# Delete any old ".config" (generated by the C implementation) and
# "._config" (generated by us), if present.
def rm_if_exists(f):
if os.path.exists(f):
os.remove(f)
rm_if_exists(".config")
rm_if_exists("._config")
def compare_configs(arch):
if equal_configs():
print("{:14}OK".format(arch))
else:
print("{:14}FAIL".format(arch))
fail()
def equal_configs():
with open(".config") as f:
their = f.readlines()
# Strip the header generated by 'conf'
i = 0
for line in their:
if not line.startswith("#") or \
re.match(r"# CONFIG_(\w+) is not set", line):
break
i += 1
their = their[i:]
try:
f = open("._config")
except EnvironmentError as e:
if e.errno != errno.ENOENT:
raise
print("._config not found. Did you forget to apply the Makefile patch?")
return False
else:
with f:
our = f.readlines()
if their == our:
return True
# Print a unified diff to help debugging
print("Mismatched .config's! Unified diff:")
sys.stdout.writelines(difflib.unified_diff(their, our, fromfile="their",
tofile="our"))
return False
if __name__ == "__main__":
run_tests()