Update choice tests, get rid of some old tests

Need to manually set the mode of the choice now.

Dependencies get a huge workout just from lack of global invalidation,
so the manual dependency tests might be redundant. Would be tricky to
reuse the old tests as is too, so they would need to be restructured at
least.

1 files changed, 85 insertions, 135 deletions

diff --git a/testsuite.py b/testsuite.py
index f6f9c98..4721349 100644
--- a/testsuite.py
+++ b/testsuite.py
@@ -1284,11 +1284,8 @@ g
     c.load_config("Kconfiglib/tests/config_indented")
     verify_value("IGNOREME", "y")
 
-    #
-    # .config
-    #
 
-    print("Testing Config separation...")
+    print("Testing Kconfig separation...")
 
     c1 = Kconfig("Kconfiglib/tests/Kmisc", warn=False)
     c2 = Kconfig("Kconfiglib/tests/Kmisc", warn=False)
@@ -1310,9 +1307,6 @@ g
            (c1_comment.kconfig is c1) and (c2_comment.kconfig is c2),
            "Config instance state separation or .config is broken")
 
-    #
-    # Imply semantics
-    #
 
     print("Testing imply semantics...")
 
@@ -1408,9 +1402,6 @@ g
     assign_and_verify("IMPLIED_BOOL", 0)
     assign_and_verify("IMPLIED_BOOL", 2)
 
-    #
-    # Choice semantics
-    #
 
     print("Testing choice semantics...")
 
@@ -1422,60 +1413,66 @@ g
       choice_no_type_tristate, choice_missing_member_type_1, \
       choice_missing_member_type_2, choice_weird_syms = get_choices(c)
 
-    for choice in (choice_bool, choice_bool_opt, choice_bool_m,
-                   choice_defaults):
+    for choice in choice_bool, choice_bool_opt, choice_bool_m, choice_defaults:
         verify(choice.type == BOOL,
                "choice {} should have type bool".format(choice.name))
 
-    # TODO: Assignment to choice symbols is less magic now. Update these tests.
-
-    # TODO: fix this laters. type automatically changed.
-    #for choice in (choice_tristate, choice_tristate_opt, choice_tristate_m):
-    #    verify(choice.type == TRISTATE,
-    #           "choice {} should have type tristate"
-    #           .format(choice.name))
-
-    #def select_and_verify(sym):
-    #    choice = get_parent(sym)
-    #    sym.set_value(2)
-    #    verify(choice.str_value == "y",
-    #           "The mode of the choice should be y after selecting a symbol")
-    #    verify(sym.choice.selection is sym,
-    #           "{} should be the selected choice symbol"
-    #           .format(sym.name))
-    #    verify(choice.selection is sym,
-    #           "{} should be the selected symbol".format(sym.name))
-    #    verify(choice.user_selection is sym,
-    #           "{} should be the user selection of the choice"
-    #           .format(sym.name))
-
-    #def select_and_verify_all(choice):
-    #    # Select in forward order
-    #    for sym in choice.syms:
-    #        select_and_verify(sym)
-    #    # Select in reverse order
-    #    for i in range(len(choice.syms) - 1, 0, -1):
-    #        select_and_verify(choice.syms[i])
-
-    #def verify_mode(choice, no_modules_mode, modules_mode):
-    #    c.modules.set_value(0)
-    #    choice_mode = choice.tri_value
-    #    verify(choice_mode == no_modules_mode,
-    #           'Wrong mode for choice {} with no modules. Expected {}, got {}.'
-    #           .format(choice.name, no_modules_mode, choice_mode))
-
-    #    c.modules.set_value(2)
-    #    choice_mode = choice.tri_value
-    #    verify(choice_mode == modules_mode,
-    #           'Wrong mode for choice {} with modules. Expected {}, got {}.'
-    #           .format(choice.name, modules_mode, choice_mode))
-
-    #verify_mode(choice_bool,         2, 2)
-    #verify_mode(choice_bool_opt,     0, 0)
-    #verify_mode(choice_tristate,     2, 1)
-    #verify_mode(choice_tristate_opt, 0, 0)
-    #verify_mode(choice_bool_m,       0, 2)
-    #verify_mode(choice_tristate_m,   0, 1)
+    for choice in choice_tristate, choice_tristate_opt, choice_tristate_m:
+        verify(choice.orig_type == TRISTATE,
+               "choice {} should have type tristate"
+               .format(choice.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 be y when selected")
+
+        verify(sym.user_value != 2,
+               sym.name + " should not have user value y, because choice "
+                          "y mode selections are remembered on the choice "
+                          "itself")
+
+        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):
+        # 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, no_modules_mode, modules_mode):
+        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(choice_bool,         2, 2)
+    verify_mode(choice_bool_opt,     0, 0)
+    verify_mode(choice_tristate,     2, 1)
+    verify_mode(choice_tristate_opt, 0, 0)
+    verify_mode(choice_bool_m,       0, 2)
+    verify_mode(choice_tristate_m,   0, 1)
 
     # Test defaults
 
@@ -1493,42 +1490,42 @@ g
            "Non-visible choice symbols should cause the next default to be "
            "considered")
 
-    # Test "y" mode selection
+    # Test y mode selection
 
-    #c.modules.set_value(2)
+    c.modules.set_value(2)
 
-    #select_and_verify_all(choice_bool)
-    #select_and_verify_all(choice_bool_opt)
-    #select_and_verify_all(choice_tristate)
-    #select_and_verify_all(choice_tristate_opt)
+    select_and_verify_all(choice_bool)
+    select_and_verify_all(choice_bool_opt)
+    select_and_verify_all(choice_tristate)
+    select_and_verify_all(choice_tristate_opt)
     # For BOOL_M, the mode should have been promoted
-    #select_and_verify_all(choice_bool_m)
+    select_and_verify_all(choice_bool_m)
 
-    # Test "m" mode selection...
+    # Test m mode selection
 
-    # ...for a choice that can also be in "y" mode
+    choice_tristate.set_value(1)
+    assign_and_verify_value("T_1", 1, 1)
+    assign_and_verify_value("T_2", 1, 1)
 
-    #for sym_name in ("T_1", "T_2"):
-    #    assign_and_verify_value(sym_name, 1, 1)
-    #    verify(choice_tristate.tri_value == 1,
-    #           'Selecting {} to "m" should have changed the mode of the '
-    #           'choice to "m"'.format(sym_name))
+    c.syms["T_1"].set_value(0)  # Check that this is remembered later
 
-    #    assign_and_verify_value(sym_name, 2, 2)
-    #    verify(choice_tristate.tri_value == 2 and
-    #           choice_tristate.selection is c.syms[sym_name],
-    #           'Selecting {} to "y" should have changed the mode of the '
-    #           'choice to "y" and made it the selection'.format(sym_name))
+    # Switching to y mode should cause T_1 to become selected
+    choice_tristate.set_value(2)
+    verify_value("T_1", 2)
+    verify_value("T_2", 0)
 
-    # ...for a choice that can only be in "m" mode
+    # Switching back to m mode should restore the old values
+    choice_tristate.set_value(1)
+    verify_value("T_1", 0)
+    verify_value("T_2", 1)
 
-    #for sym_name in ("TM_1", "TM_2"):
-    #    assign_and_verify_value(sym_name, 1, 1)
-    #    assign_and_verify_value(sym_name, 0, 0)
-    #    # "y" should be truncated
-    #    assign_and_verify_value(sym_name, 2, 1)
-    #    verify(choice_tristate_m.tri_value == 1,
-    #           'A choice that can only be in m mode was not')
+    assign_and_verify_value("TM_1", 1, 1)
+    assign_and_verify_value("TM_1", 2, 1)  # Ignored
+    verify(choice_tristate_m.tri_value == 1,
+           "m-visible choice got invalid mode")
+
+    assign_and_verify_value("TM_1", 0, 0)
+    assign_and_verify_value("TM_1", 2, 0)  # Ignored
 
     # Verify that choices with no explicitly specified type get the type of the
     # first contained symbol with a type
@@ -1560,8 +1557,6 @@ g
                sym.nodes[0].parent.item is choice_weird_syms,
                "{} should be a normal choice symbol".format(sym.name))
 
-    # TODO: parent stuff
-
     def verify_is_weird_choice_symbol(name):
         sym = c.syms[name]
         verify(sym.choice is None and
@@ -1579,51 +1574,6 @@ g
     verify_is_weird_choice_symbol("WS8")
     verify_is_normal_choice_symbol("WS9")
 
-    #
-    # Object dependencies
-    #
-
-    print("Testing object dependencies...")
-
-    # Note: This tests an internal API
-
-    c = Kconfig("Kconfiglib/tests/Kdep")
-
-    # TODO: reintroduce these somehow
-
-    #def verify_dependent(sym_name, deps_names):
-    #    sym = c.syms[sym_name]
-    #    deps = [c.syms[name] for name in deps_names]
-    #    sym_deps = sym._get_dependent()
-    #    verify(len(sym_deps) == len(set(sym_deps)),
-    #           "{}'s dependencies contains duplicates".format(sym_name))
-    #    sym_deps = [item for item in sym_deps
-    #                     if not isinstance(item, Choice)]
-    #    verify(len(sym_deps) == len(deps),
-    #           "Wrong number of dependent symbols for {}".format(sym_name))
-    #    for dep in deps:
-    #        verify(dep in sym_deps, "{} should depend on {}".
-    #                                format(dep.name, sym_name))
-
-    ## Test twice to cover dependency caching
-    #for i in range(0, 2):
-    #    n_deps = 39
-    #    # Verify that D1, D2, .., D<n_deps> are dependent on D
-    #    verify_dependent("D", ("D{}".format(i) for i in range(1, n_deps + 1)))
-    #    # Choices
-    #    verify_dependent("A", ("B", "C"))
-    #    verify_dependent("B", ("A", "C"))
-    #    verify_dependent("C", ("A", "B"))
-    #    verify_dependent("S", ("A", "B", "C"))
-
-    # Verify that the last symbol depends on the first in a long chain of
-    # dependencies. Test twice to cover dependency caching.
-
-    #c = Kconfig("Kconfiglib/tests/Kchain")
-
-    #for i in range(0, 2):
-    #    verify(c.syms["CHAIN_26"] in c.syms["CHAIN_1"]._get_dependent(),
-    #           "Dependency chain broken")
 
     print("Testing compatibility with weird selects/implies...")