phytium-standalone-sdk/tools/build/Kconfiglib/testsuite.py

# 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()