You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3203 lines
101 KiB
3203 lines
101 KiB
# 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()
|
|
|