Remove MvS status codes and update test

kernel/test/functions/test_factorial.py

@@ -6,7 +6,8 @@ import math
 class TestFactorial(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
+        print("Root: %s" % self.root)
         self.mvk = ModelverseKernel(self.root)
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
@@ -34,74 +35,74 @@ class TestFactorial(unittest.TestCase):
     def helper_construct_and_invoke(self, param, result, fail=False):
         # Try to follow the same naming as in the dot file
 
-        var_value_4 = self.mvs.execute("CN", [])[0]
-        var_4 = self.mvs.execute("CNV", ["accumulation"])[0]
-        signature_4 = self.mvs.execute("CN", [])[0]
-        params_4 = self.mvs.execute("CN", [])[0]
-        body_4 = self.mvs.execute("CN", [])[0]
-        params_4_a = self.mvs.execute("CN", [])[0]
-        invoke_params = self.mvs.execute("CN", [])[0]
+        var_value_4 = self.mvs.execute("CN", [])
+        var_4 = self.mvs.execute("CNV", ["accumulation"])
+        signature_4 = self.mvs.execute("CN", [])
+        params_4 = self.mvs.execute("CN", [])
+        body_4 = self.mvs.execute("CN", [])
+        params_4_a = self.mvs.execute("CN", [])
+        invoke_params = self.mvs.execute("CN", [])
 
         var_1 = self.primitives["integer_subtraction"]
         var_2 = self.primitives["integer_multiplication"]
         var_3 = self.primitives["integer_gt"]
 
-        param_1a = self.mvs.execute("CN", [])[0]
-        param_1b = self.mvs.execute("CN", [])[0]
-        param_2a = self.mvs.execute("CN", [])[0]
-        param_2b = self.mvs.execute("CN", [])[0]
-        param_3a = self.mvs.execute("CN", [])[0]
-        param_3b = self.mvs.execute("CN", [])[0]
-        param_4a = self.mvs.execute("CN", [])[0]
-        param_4b = self.mvs.execute("CN", [])[0]
-        params_4_a = self.mvs.execute("CN", [])[0]
-
-        value_1 = self.mvs.execute("CNV", [1])[0]
-        value_2 = self.mvs.execute("CNV", [1])[0]
-        value_3 = self.mvs.execute("CNV", [1])[0]
-        value_4 = self.mvs.execute("CNV", [param])[0]
-        value_a = self.mvs.execute("CNV", ["a"])[0]
-        value_b = self.mvs.execute("CNV", ["b"])[0]
-        value_c = self.mvs.execute("CNV", ["c"])[0]
-        value_a2 = self.mvs.execute("CNV", ["a"])[0]
-        value_b2 = self.mvs.execute("CNV", ["b"])[0]
-        value_a3 = self.mvs.execute("CNV", ["a"])[0]
-        value_b3 = self.mvs.execute("CNV", ["b"])[0]
-        value_n = self.mvs.execute("CNV", ["n"])[0]
-        value_n2 = self.mvs.execute("CNV", ["n"])[0]
-
-        access_resolve_4 = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        access_resolve_7 = self.mvs.execute("CNV", [{"value":"access"}])[0]
-
-        if_1 = self.mvs.execute("CNV", [{"value":"if"}])[0]
-        call_1 = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        call_2 = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        call_3 = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        call_4 = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        invoke_factorial = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        resolve_2 = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        resolve_4 = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        resolve_6 = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        resolve_7 = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        resolve_10 = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        access_1 = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        access_2 = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        access_3 = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        return_1 = self.mvs.execute("CNV", [{"value":"return"}])[0]
-        return_2 = self.mvs.execute("CNV", [{"value":"return"}])[0]
-        const_1 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        const_2 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        const_3 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        const_4 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        const_5 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        param_1a = self.mvs.execute("CN", [])
+        param_1b = self.mvs.execute("CN", [])
+        param_2a = self.mvs.execute("CN", [])
+        param_2b = self.mvs.execute("CN", [])
+        param_3a = self.mvs.execute("CN", [])
+        param_3b = self.mvs.execute("CN", [])
+        param_4a = self.mvs.execute("CN", [])
+        param_4b = self.mvs.execute("CN", [])
+        params_4_a = self.mvs.execute("CN", [])
+
+        value_1 = self.mvs.execute("CNV", [1])
+        value_2 = self.mvs.execute("CNV", [1])
+        value_3 = self.mvs.execute("CNV", [1])
+        value_4 = self.mvs.execute("CNV", [param])
+        value_a = self.mvs.execute("CNV", ["a"])
+        value_b = self.mvs.execute("CNV", ["b"])
+        value_c = self.mvs.execute("CNV", ["c"])
+        value_a2 = self.mvs.execute("CNV", ["a"])
+        value_b2 = self.mvs.execute("CNV", ["b"])
+        value_a3 = self.mvs.execute("CNV", ["a"])
+        value_b3 = self.mvs.execute("CNV", ["b"])
+        value_n = self.mvs.execute("CNV", ["n"])
+        value_n2 = self.mvs.execute("CNV", ["n"])
+
+        access_resolve_4 = self.mvs.execute("CNV", [{"value":"access"}])
+        access_resolve_7 = self.mvs.execute("CNV", [{"value":"access"}])
+
+        if_1 = self.mvs.execute("CNV", [{"value":"if"}])
+        call_1 = self.mvs.execute("CNV", [{"value":"call"}])
+        call_2 = self.mvs.execute("CNV", [{"value":"call"}])
+        call_3 = self.mvs.execute("CNV", [{"value":"call"}])
+        call_4 = self.mvs.execute("CNV", [{"value":"call"}])
+        invoke_factorial = self.mvs.execute("CNV", [{"value":"call"}])
+        resolve_2 = self.mvs.execute("CNV", [{"value":"resolve"}])
+        resolve_4 = self.mvs.execute("CNV", [{"value":"resolve"}])
+        resolve_6 = self.mvs.execute("CNV", [{"value":"resolve"}])
+        resolve_7 = self.mvs.execute("CNV", [{"value":"resolve"}])
+        resolve_10 = self.mvs.execute("CNV", [{"value":"resolve"}])
+        access_1 = self.mvs.execute("CNV", [{"value":"access"}])
+        access_2 = self.mvs.execute("CNV", [{"value":"access"}])
+        access_3 = self.mvs.execute("CNV", [{"value":"access"}])
+        return_1 = self.mvs.execute("CNV", [{"value":"return"}])
+        return_2 = self.mvs.execute("CNV", [{"value":"return"}])
+        const_1 = self.mvs.execute("CNV", [{"value":"constant"}])
+        const_2 = self.mvs.execute("CNV", [{"value":"constant"}])
+        const_3 = self.mvs.execute("CNV", [{"value":"constant"}])
+        const_4 = self.mvs.execute("CNV", [{"value":"constant"}])
+        const_5 = self.mvs.execute("CNV", [{"value":"constant"}])
 
         # Rebind the invoke_factorial to the initial IP
         root = self.root
-        _globals = self.mvs.execute("RD", [root, "__hierarchy"])[0]
-        self.mvs.execute("DE", [self.mvs.execute("RDE", [_globals, "__IP"])[0]])
+        _globals = self.mvs.execute("RD", [root, "__hierarchy"])
+        self.mvs.execute("DE", [self.mvs.execute("RDE", [_globals, "__IP"])])
         self.mvs.execute("CD", [_globals, "__IP", invoke_factorial])
 
-        t = self.mvs.execute("CE", [_globals, var_value_4])[0]
+        t = self.mvs.execute("CE", [_globals, var_value_4])
         self.mvs.execute("CE", [t, var_4])
 
         self.mvs.execute("CD", [var_value_4, "value", signature_4])
@@ -113,7 +114,7 @@ class TestFactorial(unittest.TestCase):
         self.mvs.execute("CD", [if_1, "then", return_2])
         self.mvs.execute("CD", [if_1, "else", return_1])
 
-        node_3 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        node_3 = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [call_1, "func", node_3])
         self.mvs.execute("CD", [node_3, "node", self.primitives["integer_gt"]])
 
@@ -132,7 +133,7 @@ class TestFactorial(unittest.TestCase):
         self.mvs.execute("CD", [const_2, "node", value_2])
 
         self.mvs.execute("CD", [return_2, "value", call_2])
-        node_2 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        node_2 = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [call_2, "func", node_2])
         self.mvs.execute("CD", [node_2, "node", self.primitives["integer_multiplication"]])
 
@@ -152,7 +153,7 @@ class TestFactorial(unittest.TestCase):
         self.mvs.execute("CD", [call_3, "last_param", param_3a])
         self.mvs.execute("CD", [param_3a, "name", value_n])
         self.mvs.execute("CD", [param_3a, "value", call_4])
-        node_1 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        node_1 = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [call_4, "func", node_1])
         self.mvs.execute("CD", [node_1, "node", self.primitives["integer_subtraction"]])
 
@@ -180,7 +181,7 @@ class TestFactorial(unittest.TestCase):
 
         execute_until_finished(self.mvk, self.mvs, "initialize_new_task", [])
 
-        t = self.mvs.execute("CE", [self.mvs.execute("RD", [self.mvs.execute("RD", [root, "task_1"])[0], "globals"])[0] , var_value_4])[0]
+        t = self.mvs.execute("CE", [self.mvs.execute("RD", [self.mvs.execute("RD", [root, "task_1"]), "globals"]), var_value_4])
         self.mvs.execute("CE", [t, var_4])
 
         ### Execute rules

kernel/test/functions/test_fib_naive.py

@@ -6,7 +6,7 @@ import math
 class TestFibNaive(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
@@ -46,80 +46,80 @@ class TestFibNaive(unittest.TestCase):
     def helper_construct_and_invoke(self, param, result, fail=False):
         # Try to follow the same naming as in the dot file
 
-        var_value_4 = self.mvs.execute("CN", [])[0]
-        var_4 = self.mvs.execute("CNV", ["function"])[0]
-        signature_4 = self.mvs.execute("CN", [])[0]
-        params_4 = self.mvs.execute("CN", [])[0]
-        body_4 = self.mvs.execute("CN", [])[0]
-        params_4_a = self.mvs.execute("CN", [])[0]
-        invoke_params = self.mvs.execute("CN", [])[0]
-
-        param_1a = self.mvs.execute("CN", [])[0]
-        param_1b = self.mvs.execute("CN", [])[0]
-        param_2a = self.mvs.execute("CN", [])[0]
-        param_2b = self.mvs.execute("CN", [])[0]
-        param_3a = self.mvs.execute("CN", [])[0]
-        param_3b = self.mvs.execute("CN", [])[0]
-        param_4a = self.mvs.execute("CN", [])[0]
-        param_4b = self.mvs.execute("CN", [])[0]
-        param_5a = self.mvs.execute("CN", [])[0]
-        param_5b = self.mvs.execute("CN", [])[0]
-        param_6a = self.mvs.execute("CN", [])[0]
-        param_6b = self.mvs.execute("CN", [])[0]
-        params_4_a = self.mvs.execute("CN", [])[0]
-
-        value_1 = self.mvs.execute("CNV", [1])[0]
-        value_2 = self.mvs.execute("CNV", [1])[0]
-        value_3 = self.mvs.execute("CNV", [1])[0]
-        value_4 = self.mvs.execute("CNV", [param])[0]
-        value_5 = self.mvs.execute("CNV", [2])[0]
-        value_a = self.mvs.execute("CNV", ["a"])[0]
-        value_b = self.mvs.execute("CNV", ["b"])[0]
-        value_c = self.mvs.execute("CNV", ["c"])[0]
-        value_a2 = self.mvs.execute("CNV", ["a"])[0]
-        value_b2 = self.mvs.execute("CNV", ["b"])[0]
-        value_a3 = self.mvs.execute("CNV", ["a"])[0]
-        value_b3 = self.mvs.execute("CNV", ["b"])[0]
-        value_a4 = self.mvs.execute("CNV", ["a"])[0]
-        value_b4 = self.mvs.execute("CNV", ["b"])[0]
-        value_n = self.mvs.execute("CNV", ["n"])[0]
-        value_n2 = self.mvs.execute("CNV", ["n"])[0]
-        value_n3 = self.mvs.execute("CNV", ["n"])[0]
-
-        access_resolve_4 = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        access_resolve_7 = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        access_resolve_8 = self.mvs.execute("CNV", [{"value":"access"}])[0]
-
-        if_1 = self.mvs.execute("CNV", [{"value":"if"}])[0]
-        call_1 = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        call_2 = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        call_3 = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        call_4 = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        call_5 = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        call_6 = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        invoke_fib = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        resolve_2 = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        resolve_4 = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        resolve_6 = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        resolve_7 = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        resolve_8 = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        resolve_11 = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        access_1 = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        access_3 = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        access_4 = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        return_1 = self.mvs.execute("CNV", [{"value":"return"}])[0]
-        return_2 = self.mvs.execute("CNV", [{"value":"return"}])[0]
-        const_1 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        const_2 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        const_3 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        const_4 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        const_5 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        const_6 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        var_value_4 = self.mvs.execute("CN", [])
+        var_4 = self.mvs.execute("CNV", ["function"])
+        signature_4 = self.mvs.execute("CN", [])
+        params_4 = self.mvs.execute("CN", [])
+        body_4 = self.mvs.execute("CN", [])
+        params_4_a = self.mvs.execute("CN", [])
+        invoke_params = self.mvs.execute("CN", [])
+
+        param_1a = self.mvs.execute("CN", [])
+        param_1b = self.mvs.execute("CN", [])
+        param_2a = self.mvs.execute("CN", [])
+        param_2b = self.mvs.execute("CN", [])
+        param_3a = self.mvs.execute("CN", [])
+        param_3b = self.mvs.execute("CN", [])
+        param_4a = self.mvs.execute("CN", [])
+        param_4b = self.mvs.execute("CN", [])
+        param_5a = self.mvs.execute("CN", [])
+        param_5b = self.mvs.execute("CN", [])
+        param_6a = self.mvs.execute("CN", [])
+        param_6b = self.mvs.execute("CN", [])
+        params_4_a = self.mvs.execute("CN", [])
+
+        value_1 = self.mvs.execute("CNV", [1])
+        value_2 = self.mvs.execute("CNV", [1])
+        value_3 = self.mvs.execute("CNV", [1])
+        value_4 = self.mvs.execute("CNV", [param])
+        value_5 = self.mvs.execute("CNV", [2])
+        value_a = self.mvs.execute("CNV", ["a"])
+        value_b = self.mvs.execute("CNV", ["b"])
+        value_c = self.mvs.execute("CNV", ["c"])
+        value_a2 = self.mvs.execute("CNV", ["a"])
+        value_b2 = self.mvs.execute("CNV", ["b"])
+        value_a3 = self.mvs.execute("CNV", ["a"])
+        value_b3 = self.mvs.execute("CNV", ["b"])
+        value_a4 = self.mvs.execute("CNV", ["a"])
+        value_b4 = self.mvs.execute("CNV", ["b"])
+        value_n = self.mvs.execute("CNV", ["n"])
+        value_n2 = self.mvs.execute("CNV", ["n"])
+        value_n3 = self.mvs.execute("CNV", ["n"])
+
+        access_resolve_4 = self.mvs.execute("CNV", [{"value":"access"}])
+        access_resolve_7 = self.mvs.execute("CNV", [{"value":"access"}])
+        access_resolve_8 = self.mvs.execute("CNV", [{"value":"access"}])
+
+        if_1 = self.mvs.execute("CNV", [{"value":"if"}])
+        call_1 = self.mvs.execute("CNV", [{"value":"call"}])
+        call_2 = self.mvs.execute("CNV", [{"value":"call"}])
+        call_3 = self.mvs.execute("CNV", [{"value":"call"}])
+        call_4 = self.mvs.execute("CNV", [{"value":"call"}])
+        call_5 = self.mvs.execute("CNV", [{"value":"call"}])
+        call_6 = self.mvs.execute("CNV", [{"value":"call"}])
+        invoke_fib = self.mvs.execute("CNV", [{"value":"call"}])
+        resolve_2 = self.mvs.execute("CNV", [{"value":"resolve"}])
+        resolve_4 = self.mvs.execute("CNV", [{"value":"resolve"}])
+        resolve_6 = self.mvs.execute("CNV", [{"value":"resolve"}])
+        resolve_7 = self.mvs.execute("CNV", [{"value":"resolve"}])
+        resolve_8 = self.mvs.execute("CNV", [{"value":"resolve"}])
+        resolve_11 = self.mvs.execute("CNV", [{"value":"resolve"}])
+        access_1 = self.mvs.execute("CNV", [{"value":"access"}])
+        access_3 = self.mvs.execute("CNV", [{"value":"access"}])
+        access_4 = self.mvs.execute("CNV", [{"value":"access"}])
+        return_1 = self.mvs.execute("CNV", [{"value":"return"}])
+        return_2 = self.mvs.execute("CNV", [{"value":"return"}])
+        const_1 = self.mvs.execute("CNV", [{"value":"constant"}])
+        const_2 = self.mvs.execute("CNV", [{"value":"constant"}])
+        const_3 = self.mvs.execute("CNV", [{"value":"constant"}])
+        const_4 = self.mvs.execute("CNV", [{"value":"constant"}])
+        const_5 = self.mvs.execute("CNV", [{"value":"constant"}])
+        const_6 = self.mvs.execute("CNV", [{"value":"constant"}])
 
         # Rebind the invoke_fib to the initial IP
         root = self.root
-        _globals = self.mvs.execute("RD", [root, "__hierarchy"])[0]
-        self.mvs.execute("DE", [self.mvs.execute("RDE", [_globals, "__IP"])[0]])
+        _globals = self.mvs.execute("RD", [root, "__hierarchy"])
+        self.mvs.execute("DE", [self.mvs.execute("RDE", [_globals, "__IP"])])
         self.mvs.execute("CD", [_globals, "__IP", invoke_fib])
 
         self.mvs.execute("CD", [var_value_4, "value", signature_4])
@@ -131,7 +131,7 @@ class TestFibNaive(unittest.TestCase):
         self.mvs.execute("CD", [if_1, "then", return_2])
         self.mvs.execute("CD", [if_1, "else", return_1])
 
-        node_3 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        node_3 = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [call_1, "func", node_3])
         self.mvs.execute("CD", [node_3, "node", self.primitives["integer_gt"]])
         self.mvs.execute("CD", [call_1, "params", param_1a])
@@ -149,7 +149,7 @@ class TestFibNaive(unittest.TestCase):
         self.mvs.execute("CD", [const_2, "node", value_2])
 
         self.mvs.execute("CD", [return_2, "value", call_2])
-        node_2 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        node_2 = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [call_2, "func", node_2])
         self.mvs.execute("CD", [node_2, "node", self.primitives["integer_addition"]])
 
@@ -168,7 +168,7 @@ class TestFibNaive(unittest.TestCase):
         self.mvs.execute("CD", [call_3, "last_param", param_3a])
         self.mvs.execute("CD", [param_3a, "name", value_n])
         self.mvs.execute("CD", [param_3a, "value", call_4])
-        node_1 = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        node_1 = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [call_4, "func", node_1])
         self.mvs.execute("CD", [node_1, "node", self.primitives["integer_subtraction"]])
 
@@ -216,7 +216,7 @@ class TestFibNaive(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs, "initialize_new_task", ["task_1"])
 
         # Define in globals for task, kind of a hack...
-        t = self.mvs.execute("CE", [self.mvs.execute("RD", [self.mvs.execute("RD", [root, "task_1"])[0], "globals"])[0] , var_value_4])[0]
+        t = self.mvs.execute("CE", [self.mvs.execute("RD", [self.mvs.execute("RD", [root, "task_1"]), "globals"]) , var_value_4])
         self.mvs.execute("CE", [t, var_4])
 
         ### Execute rules

kernel/test/functions/utils.py

@@ -32,21 +32,21 @@ class MvSWrapper(object):
         retval = self.mapping[command](*params)
         retval = json.loads(json.dumps(retval))
 
-        return [retval[0]]
+        return retval
 
 def add_new_task(root, mvs, taskname):
-    hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
-    initial = mvs.execute("RD", [hierarchy, "__IP"])[0]
+    hierarchy = mvs.execute("RD", [root, "__hierarchy"])
+    initial = mvs.execute("RD", [hierarchy, "__IP"])
 
-    task_root = mvs.execute("CN", [])[0]
-    _globals = mvs.execute("CN", [])[0]
-    frame = mvs.execute("CN", [])[0]
-    evalstack = mvs.execute("CN", [])[0]
-    symbols = mvs.execute("CN", [])[0]
-    _input = mvs.execute("CN", [])[0]
-    _output = mvs.execute("CN", [])[0]
-    returnvalue = mvs.execute("CN", [])[0]
-    phase = mvs.execute("CNV", ["init"])[0]
+    task_root = mvs.execute("CN", [])
+    _globals = mvs.execute("CN", [])
+    frame = mvs.execute("CN", [])
+    evalstack = mvs.execute("CN", [])
+    symbols = mvs.execute("CN", [])
+    _input = mvs.execute("CN", [])
+    _output = mvs.execute("CN", [])
+    returnvalue = mvs.execute("CN", [])
+    phase = mvs.execute("CNV", ["init"])
 
     mvs.execute("CD", [root, taskname, task_root])
     mvs.execute("CD", [task_root, "frame", frame])
@@ -72,49 +72,49 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
             break
         response = []
         for command, param in mvs_commands:
-            response.append(mvs.execute(command, param)[0])
+            response.append(mvs.execute(command, param))
 
 def get_inst(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    inst = mvs.execute("RD", [task_frame, "IP"])[0]
-    return mvs.execute("RV", [inst])[0]["value"]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    inst = mvs.execute("RD", [task_frame, "IP"])
+    return mvs.execute("RV", [inst])["value"]
 
 def get_phase(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    phase = mvs.execute("RD", [task_frame, "phase"])[0]
-    return mvs.execute("RV", [phase])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    phase = mvs.execute("RD", [task_frame, "phase"])
+    return mvs.execute("RV", [phase])
 
 def get_returnvalue(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])[0]
-    return mvs.execute("RV", [returnvalue])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])
+    return mvs.execute("RV", [returnvalue])
 
 def get_inst_ref(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    return mvs.execute("RD", [task_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    return mvs.execute("RD", [task_frame, "IP"])
 
 def get_returnvalue_ref(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    return mvs.execute("RD", [task_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    return mvs.execute("RD", [task_frame, "returnvalue"])
 
 def get_phase_ref(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    phase = mvs.execute("RD", [task_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    phase = mvs.execute("RD", [task_frame, "phase"])
     return phase
 
 def read_primitive_interfaces(root, mvs):
-    hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
-    primitives = mvs.execute("RD", [hierarchy, "primitives"])[0]
-    keys = mvs.execute("RDK", [primitives])[0]
+    hierarchy = mvs.execute("RD", [root, "__hierarchy"])
+    primitives = mvs.execute("RD", [hierarchy, "primitives"])
+    keys = mvs.execute("RDK", [primitives])
     d = {}
     for k in keys:
-        value = mvs.execute("RDN", [primitives, k])[0]
-        name = mvs.execute("RV", [k])[0]
+        value = mvs.execute("RDN", [primitives, k])
+        name = mvs.execute("RV", [k])
         d[name] = value
     return d

kernel/test/instructions/test_instruction_access.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class Testaccess(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -26,20 +26,20 @@ class Testaccess(unittest.TestCase):
         """
         Test the access of a variable which contains value "a"
         """
-        self.var = self.mvs.execute("CN", [])[0]
-        self.value = self.mvs.execute("CN", [])[0]
+        self.var = self.mvs.execute("CN", [])
+        self.value = self.mvs.execute("CN", [])
 
-        self.inst = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        self.resolve = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"access"}])
+        self.resolve = self.mvs.execute("CNV", [{"value":"resolve"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
 
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
+        self.value_a = self.mvs.execute("CNV", ["a"])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.resolve])
         self.mvs.execute("CD", [self.resolve, "var", self.var])
         self.mvs.execute("CD", [self.value, "value", self.const_a])
-        t = self.mvs.execute("CE", [self.symbols, self.value])[0]
+        t = self.mvs.execute("CE", [self.symbols, self.value])
         self.mvs.execute("CE", [t, self.var])
 
         ### Execute rules

kernel/test/instructions/test_instruction_assign.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestAssign(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -27,14 +27,14 @@ class TestAssign(unittest.TestCase):
         Test the code:
             a = True
         """
-        self.var = self.mvs.execute("CN", [])[0]
-        self.value = self.mvs.execute("CN", [])[0]
-        self.previous = self.mvs.execute("CN", [])[0]
-        self.const = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_value = self.mvs.execute("CNV", [True])[0]
+        self.var = self.mvs.execute("CN", [])
+        self.value = self.mvs.execute("CN", [])
+        self.previous = self.mvs.execute("CN", [])
+        self.const = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_value = self.mvs.execute("CNV", [True])
 
-        self.inst = self.mvs.execute("CNV", [{"value":"assign"}])[0]
-        self.resolve = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"assign"}])
+        self.resolve = self.mvs.execute("CNV", [{"value":"resolve"}])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.resolve])
@@ -42,7 +42,7 @@ class TestAssign(unittest.TestCase):
         self.mvs.execute("CD", [self.resolve, "var", self.var])
         self.mvs.execute("CD", [self.value, "value", self.previous])
         self.mvs.execute("CD", [self.const, "node", self.const_value])
-        t = self.mvs.execute("CE", [self.symbols, self.value])[0]
+        t = self.mvs.execute("CE", [self.symbols, self.value])
         self.mvs.execute("CE", [t, self.var])
 
         ### Execute rules
@@ -79,10 +79,10 @@ class TestAssign(unittest.TestCase):
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
 
         # Check if the new value is really assigned
-        t = self.mvs.execute("RD", [self.root, "task_1"])[0]
-        t = self.mvs.execute("RD", [t, "frame"])[0]
-        t = self.mvs.execute("RD", [t, "symbols"])[0]
-        t = self.mvs.execute("RDN", [t, self.var])[0]
-        t = self.mvs.execute("RD", [t, "value"])[0]
-        t = self.mvs.execute("RV", [t])[0]
+        t = self.mvs.execute("RD", [self.root, "task_1"])
+        t = self.mvs.execute("RD", [t, "frame"])
+        t = self.mvs.execute("RD", [t, "symbols"])
+        t = self.mvs.execute("RDN", [t, self.var])
+        t = self.mvs.execute("RD", [t, "value"])
+        t = self.mvs.execute("RV", [t])
         self.assertEquals(t, True)

kernel/test/instructions/test_instruction_break.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestBreak(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -30,16 +30,16 @@ class TestBreak(unittest.TestCase):
                 break
             c
         """
-        self.inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"while"}])
 
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_cond = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_cond = self.mvs.execute("CNV", [{"value":"constant"}])
 
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_cond = self.mvs.execute("CNV", [True])[0]
-        self.break_inst = self.mvs.execute("CNV", [{"value":"break"}])[0]
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_cond = self.mvs.execute("CNV", [True])
+        self.break_inst = self.mvs.execute("CNV", [{"value":"break"}])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_cond])

kernel/test/instructions/test_instruction_call.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class Testcall(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -31,18 +31,18 @@ class Testcall(unittest.TestCase):
             function_A()
             a
         """
-        self.params = self.mvs.execute("CN", [])[0]
-        self.var_function = self.mvs.execute("CN", [])[0]
-        self.signature = self.mvs.execute("CN", [])[0]
-        self.val_function = self.mvs.execute("CN", [])[0]
+        self.params = self.mvs.execute("CN", [])
+        self.var_function = self.mvs.execute("CN", [])
+        self.signature = self.mvs.execute("CN", [])
+        self.val_function = self.mvs.execute("CN", [])
 
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.access = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        self.resolve = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        self.ret = self.mvs.execute("CNV", [{"value":"return"}])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.access = self.mvs.execute("CNV", [{"value":"access"}])
+        self.resolve = self.mvs.execute("CNV", [{"value":"resolve"}])
+        self.ret = self.mvs.execute("CNV", [{"value":"return"}])
 
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "func", self.access])
@@ -53,7 +53,7 @@ class Testcall(unittest.TestCase):
         self.mvs.execute("CD", [self.signature, "body", self.ret])
         self.mvs.execute("CD", [self.signature, "params", self.params])
         self.mvs.execute("CD", [self.const_a, "node", self.value_a])
-        t = self.mvs.execute("CE", [self.symbols, self.val_function])[0]
+        t = self.mvs.execute("CE", [self.symbols, self.val_function])
         self.mvs.execute("CE", [t, self.var_function])
 
         ### Execute rules
@@ -110,23 +110,23 @@ class Testcall(unittest.TestCase):
             function_A(abc="def")
             a
         """
-        self.params = self.mvs.execute("CN", [])[0]
-        self.var_function = self.mvs.execute("CN", [])[0]
-        self.signature = self.mvs.execute("CN", [])[0]
-        self.val_function = self.mvs.execute("CN", [])[0]
-        self.var_abc = self.mvs.execute("CN", [])[0]
-        self.actual_arg = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.access = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        self.resolve = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        self.ret = self.mvs.execute("CNV", [{"value":"return"}])[0]
-
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_def = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_abc = self.mvs.execute("CNV", ["abc"])[0]
-        self.value_def = self.mvs.execute("CNV", ["def"])[0]
+        self.params = self.mvs.execute("CN", [])
+        self.var_function = self.mvs.execute("CN", [])
+        self.signature = self.mvs.execute("CN", [])
+        self.val_function = self.mvs.execute("CN", [])
+        self.var_abc = self.mvs.execute("CN", [])
+        self.actual_arg = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.access = self.mvs.execute("CNV", [{"value":"access"}])
+        self.resolve = self.mvs.execute("CNV", [{"value":"resolve"}])
+        self.ret = self.mvs.execute("CNV", [{"value":"return"}])
+
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_def = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_abc = self.mvs.execute("CNV", ["abc"])
+        self.value_def = self.mvs.execute("CNV", ["def"])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "func", self.access])
@@ -134,7 +134,7 @@ class Testcall(unittest.TestCase):
         self.mvs.execute("CD", [self.inst, "params", self.actual_arg])
         self.mvs.execute("CD", [self.inst, "last_param", self.actual_arg])
         self.mvs.execute("CD", [self.actual_arg, "value", self.const_def])
-        self.mvs.execute("CD", [self.actual_arg, "name", self.mvs.execute("CNV", ["abc"])[0]])
+        self.mvs.execute("CD", [self.actual_arg, "name", self.mvs.execute("CNV", ["abc"])])
         self.mvs.execute("CD", [self.const_def, "node", self.value_def])
         self.mvs.execute("CD", [self.access, "var", self.resolve])
         self.mvs.execute("CD", [self.resolve, "var", self.var_function])
@@ -142,7 +142,7 @@ class Testcall(unittest.TestCase):
         self.mvs.execute("CD", [self.signature, "body", self.ret])
         self.mvs.execute("CD", [self.signature, "params", self.params])
         self.mvs.execute("CD", [self.const_a, "node", self.value_a])
-        t = self.mvs.execute("CE", [self.symbols, self.val_function])[0]
+        t = self.mvs.execute("CE", [self.symbols, self.val_function])
         self.mvs.execute("CE", [t, self.var_function])
         self.mvs.execute("CD", [self.params, "abc", self.var_abc])
 
@@ -212,30 +212,30 @@ class Testcall(unittest.TestCase):
             function_A(a="d", b="e")
             f
         """
-        self.params = self.mvs.execute("CN", [])[0]
-        self.var_function = self.mvs.execute("CN", [])[0]
-        self.signature = self.mvs.execute("CN", [])[0]
-        self.val_function = self.mvs.execute("CN", [])[0]
-        self.var_a = self.mvs.execute("CN", [])[0]
-        self.var_b = self.mvs.execute("CN", [])[0]
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.access = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        self.resolve = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        self.ret = self.mvs.execute("CNV", [{"value":"return"}])[0]
-
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_d = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_e = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_f = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_d = self.mvs.execute("CNV", ["d"])[0]
-        self.value_e = self.mvs.execute("CNV", ["e"])[0]
-        self.value_f = self.mvs.execute("CNV", ["f"])[0]
+        self.params = self.mvs.execute("CN", [])
+        self.var_function = self.mvs.execute("CN", [])
+        self.signature = self.mvs.execute("CN", [])
+        self.val_function = self.mvs.execute("CN", [])
+        self.var_a = self.mvs.execute("CN", [])
+        self.var_b = self.mvs.execute("CN", [])
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.access = self.mvs.execute("CNV", [{"value":"access"}])
+        self.resolve = self.mvs.execute("CNV", [{"value":"resolve"}])
+        self.ret = self.mvs.execute("CNV", [{"value":"return"}])
+
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_d = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_e = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_f = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_d = self.mvs.execute("CNV", ["d"])
+        self.value_e = self.mvs.execute("CNV", ["e"])
+        self.value_f = self.mvs.execute("CNV", ["f"])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "func", self.access])
@@ -244,9 +244,9 @@ class Testcall(unittest.TestCase):
         self.mvs.execute("CD", [self.actual_arg_a, "next_param", self.actual_arg_b])
         self.mvs.execute("CD", [self.inst, "last_param", self.actual_arg_b])
         self.mvs.execute("CD", [self.actual_arg_a, "value", self.const_d])
-        self.mvs.execute("CD", [self.actual_arg_a, "name", self.mvs.execute("CNV", ["a"])[0]])
+        self.mvs.execute("CD", [self.actual_arg_a, "name", self.mvs.execute("CNV", ["a"])])
         self.mvs.execute("CD", [self.actual_arg_b, "value", self.const_e])
-        self.mvs.execute("CD", [self.actual_arg_b, "name", self.mvs.execute("CNV", ["b"])[0]])
+        self.mvs.execute("CD", [self.actual_arg_b, "name", self.mvs.execute("CNV", ["b"])])
         self.mvs.execute("CD", [self.const_a, "node", self.value_a])
         self.mvs.execute("CD", [self.const_b, "node", self.value_b])
         self.mvs.execute("CD", [self.const_d, "node", self.value_d])
@@ -257,7 +257,7 @@ class Testcall(unittest.TestCase):
         self.mvs.execute("CD", [self.val_function, "value", self.signature])
         self.mvs.execute("CD", [self.signature, "body", self.ret])
         self.mvs.execute("CD", [self.signature, "params", self.params])
-        t = self.mvs.execute("CE", [self.symbols, self.val_function])[0]
+        t = self.mvs.execute("CE", [self.symbols, self.val_function])
         self.mvs.execute("CE", [t, self.var_function])
         self.mvs.execute("CD", [self.params, "a", self.var_a])
         self.mvs.execute("CD", [self.params, "b", self.var_b])
@@ -340,34 +340,34 @@ class Testcall(unittest.TestCase):
             function_A(a="d", b="e", c="f")
             f
         """
-        self.params = self.mvs.execute("CN", [])[0]
-        self.var_function = self.mvs.execute("CN", [])[0]
-        self.signature = self.mvs.execute("CN", [])[0]
-        self.val_function = self.mvs.execute("CN", [])[0]
-        self.var_a = self.mvs.execute("CN", [])[0]
-        self.var_b = self.mvs.execute("CN", [])[0]
-        self.var_c = self.mvs.execute("CN", [])[0]
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-        self.actual_arg_c = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.access = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        self.resolve = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        self.ret = self.mvs.execute("CNV", [{"value":"return"}])[0]
-
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_d = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_e = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_f = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_d = self.mvs.execute("CNV", ["d"])[0]
-        self.value_e = self.mvs.execute("CNV", ["e"])[0]
-        self.value_f = self.mvs.execute("CNV", ["f"])[0]
+        self.params = self.mvs.execute("CN", [])
+        self.var_function = self.mvs.execute("CN", [])
+        self.signature = self.mvs.execute("CN", [])
+        self.val_function = self.mvs.execute("CN", [])
+        self.var_a = self.mvs.execute("CN", [])
+        self.var_b = self.mvs.execute("CN", [])
+        self.var_c = self.mvs.execute("CN", [])
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+        self.actual_arg_c = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.access = self.mvs.execute("CNV", [{"value":"access"}])
+        self.resolve = self.mvs.execute("CNV", [{"value":"resolve"}])
+        self.ret = self.mvs.execute("CNV", [{"value":"return"}])
+
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_d = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_e = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_f = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_d = self.mvs.execute("CNV", ["d"])
+        self.value_e = self.mvs.execute("CNV", ["e"])
+        self.value_f = self.mvs.execute("CNV", ["f"])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "func", self.access])
@@ -377,11 +377,11 @@ class Testcall(unittest.TestCase):
         self.mvs.execute("CD", [self.actual_arg_b, "next_param", self.actual_arg_c])
         self.mvs.execute("CD", [self.inst, "last_param", self.actual_arg_c])
         self.mvs.execute("CD", [self.actual_arg_a, "value", self.const_d])
-        self.mvs.execute("CD", [self.actual_arg_a, "name", self.mvs.execute("CNV", ["a"])[0]])
+        self.mvs.execute("CD", [self.actual_arg_a, "name", self.mvs.execute("CNV", ["a"])])
         self.mvs.execute("CD", [self.actual_arg_b, "value", self.const_e])
-        self.mvs.execute("CD", [self.actual_arg_b, "name", self.mvs.execute("CNV", ["b"])[0]])
+        self.mvs.execute("CD", [self.actual_arg_b, "name", self.mvs.execute("CNV", ["b"])])
         self.mvs.execute("CD", [self.actual_arg_c, "value", self.const_f])
-        self.mvs.execute("CD", [self.actual_arg_c, "name", self.mvs.execute("CNV", ["c"])[0]])
+        self.mvs.execute("CD", [self.actual_arg_c, "name", self.mvs.execute("CNV", ["c"])])
         self.mvs.execute("CD", [self.const_a, "node", self.value_a])
         self.mvs.execute("CD", [self.const_b, "node", self.value_b])
         self.mvs.execute("CD", [self.const_c, "node", self.value_c])
@@ -393,7 +393,7 @@ class Testcall(unittest.TestCase):
         self.mvs.execute("CD", [self.val_function, "value", self.signature])
         self.mvs.execute("CD", [self.signature, "body", self.ret])
         self.mvs.execute("CD", [self.signature, "params", self.params])
-        t = self.mvs.execute("CE", [self.symbols, self.val_function])[0]
+        t = self.mvs.execute("CE", [self.symbols, self.val_function])
         self.mvs.execute("CE", [t, self.var_function])
         self.mvs.execute("CD", [self.params, "a", self.var_a])
         self.mvs.execute("CD", [self.params, "b", self.var_b])

kernel/test/instructions/test_instruction_continue.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class Testcontinue(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -30,16 +30,16 @@ class Testcontinue(unittest.TestCase):
                 continue
             c
         """
-        self.inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"while"}])
 
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_cond = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_cond = self.mvs.execute("CNV", [{"value":"constant"}])
 
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_cond = self.mvs.execute("CNV", [True])[0]
-        self.continue_inst = self.mvs.execute("CNV", [{"value":"continue"}])[0]
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_cond = self.mvs.execute("CNV", [True])
+        self.continue_inst = self.mvs.execute("CNV", [{"value":"continue"}])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_cond])

kernel/test/instructions/test_instruction_declare.py

@@ -5,16 +5,16 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestDeclare(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.globals = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.globals = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -25,8 +25,8 @@ class TestDeclare(unittest.TestCase):
         self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_declare(self):
-        self.inst = self.mvs.execute("CNV", [{"value":"declare"}])[0]
-        self.var = self.mvs.execute("CN", [])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"declare"}])
+        self.var = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
@@ -38,12 +38,12 @@ class TestDeclare(unittest.TestCase):
 
         self.assertEquals(get_inst(self.root, self.mvs), "declare")
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertNotEquals(self.mvs.execute("RDN", [self.symbols, self.var])[0], None)
+        self.assertNotEquals(self.mvs.execute("RDN", [self.symbols, self.var]), None)
 
     def test_global(self):
-        self.global_symbols = self.mvs.execute("RD", [self.task_root, "globals"])[0]
-        self.inst = self.mvs.execute("CNV", [{"value":"global"}])[0]
-        self.var = self.mvs.execute("CNV", ["abc"])[0]
+        self.global_symbols = self.mvs.execute("RD", [self.task_root, "globals"])
+        self.inst = self.mvs.execute("CNV", [{"value":"global"}])
+        self.var = self.mvs.execute("CNV", ["abc"])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
@@ -55,4 +55,4 @@ class TestDeclare(unittest.TestCase):
 
         self.assertEquals(get_inst(self.root, self.mvs), "global")
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertNotEquals(self.mvs.execute("RD", [self.global_symbols, "abc"])[0], None)
+        self.assertNotEquals(self.mvs.execute("RD", [self.global_symbols, "abc"]), None)

kernel/test/instructions/test_instruction_if.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class Testif(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -31,17 +31,17 @@ class Testif(unittest.TestCase):
                 b
             c
         """
-        self.inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"if"}])
 
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_true = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_true = self.mvs.execute("CNV", [{"value":"constant"}])
 
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_true = self.mvs.execute("CNV", [True])[0]
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_true = self.mvs.execute("CNV", [True])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_true])
@@ -99,15 +99,15 @@ class Testif(unittest.TestCase):
                 a
             c
         """
-        self.inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"if"}])
 
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_true = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_true = self.mvs.execute("CNV", [{"value":"constant"}])
 
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_true = self.mvs.execute("CNV", [True])[0]
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_true = self.mvs.execute("CNV", [True])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_true])
@@ -165,17 +165,17 @@ class Testif(unittest.TestCase):
                 b
             c
         """
-        self.inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"if"}])
 
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_false = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_false = self.mvs.execute("CNV", [{"value":"constant"}])
 
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_false = self.mvs.execute("CNV", [False])[0]
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_false = self.mvs.execute("CNV", [False])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_false])
@@ -233,15 +233,15 @@ class Testif(unittest.TestCase):
                 a
             c
         """
-        self.inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"if"}])
 
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_false = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_false = self.mvs.execute("CNV", [{"value":"constant"}])
 
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_false = self.mvs.execute("CNV", [False])[0]
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_false = self.mvs.execute("CNV", [False])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_false])

kernel/test/instructions/test_instruction_input.py

@@ -5,16 +5,16 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestInput(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.task_input = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.task_input = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "input", self.task_input])
@@ -25,10 +25,10 @@ class TestInput(unittest.TestCase):
         self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_input(self):
-        self.input_value = self.mvs.execute("CN", [])[0]
-        self.inst = self.mvs.execute("CNV", [{"value":"input"}])[0]
+        self.input_value = self.mvs.execute("CN", [])
+        self.inst = self.mvs.execute("CNV", [{"value":"input"}])
 
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
+        self.value_a = self.mvs.execute("CNV", ["a"])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.task_input, "next", self.input_value])

kernel/test/instructions/test_instruction_output.py

@@ -5,17 +5,17 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestOutput(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.task_input = self.mvs.execute("CN", [])[0]
-        self.task_output = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.task_input = self.mvs.execute("CN", [])
+        self.task_output = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "input", self.task_input])
@@ -29,11 +29,11 @@ class TestOutput(unittest.TestCase):
         self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_output_value(self):
-        self.input_value = self.mvs.execute("CN", [])[0]
-        self.inst = self.mvs.execute("CNV", [{"value":"output"}])[0]
+        self.input_value = self.mvs.execute("CN", [])
+        self.inst = self.mvs.execute("CNV", [{"value":"output"}])
 
-        self.const = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
+        self.const = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "value", self.const])
@@ -59,14 +59,14 @@ class TestOutput(unittest.TestCase):
 
         self.assertEquals(get_inst(self.root, self.mvs), "output")
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [self.task_output, "value"])[0]])[0], "a")
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [self.task_output, "value"])]), "a")
 
     def test_output_node(self):
-        self.input_value = self.mvs.execute("CN", [])[0]
-        self.inst = self.mvs.execute("CNV", [{"value":"output"}])[0]
+        self.input_value = self.mvs.execute("CN", [])
+        self.inst = self.mvs.execute("CNV", [{"value":"output"}])
 
-        self.const = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value = self.mvs.execute("CN", [])[0]
+        self.const = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "value", self.const])
@@ -92,16 +92,16 @@ class TestOutput(unittest.TestCase):
 
         self.assertEquals(get_inst(self.root, self.mvs), "output")
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertEquals(self.mvs.execute("RD", [self.task_output, "value"])[0], self.value)
+        self.assertEquals(self.mvs.execute("RD", [self.task_output, "value"]), self.value)
 
     def test_output_edge(self):
-        self.input_value = self.mvs.execute("CN", [])[0]
-        self.inst = self.mvs.execute("CNV", [{"value":"output"}])[0]
+        self.input_value = self.mvs.execute("CN", [])
+        self.inst = self.mvs.execute("CNV", [{"value":"output"}])
 
-        self.const = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        a = self.mvs.execute("CN", [])[0]
-        b = self.mvs.execute("CN", [])[0]
-        self.value = self.mvs.execute("CE", [a,b])[0]
+        self.const = self.mvs.execute("CNV", [{"value":"constant"}])
+        a = self.mvs.execute("CN", [])
+        b = self.mvs.execute("CN", [])
+        self.value = self.mvs.execute("CE", [a,b])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "value", self.const])
@@ -127,4 +127,4 @@ class TestOutput(unittest.TestCase):
 
         self.assertEquals(get_inst(self.root, self.mvs), "output")
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertEquals(self.mvs.execute("RD", [self.task_output, "value"])[0], self.value)
+        self.assertEquals(self.mvs.execute("RD", [self.task_output, "value"]), self.value)

kernel/test/instructions/test_instruction_resolve.py

@@ -5,16 +5,16 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class Testresolve(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.global_task = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.global_task = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -28,14 +28,14 @@ class Testresolve(unittest.TestCase):
         """
         Test the resolution of a local variable
         """
-        self.var = self.mvs.execute("CN", [])[0]
-        self.value = self.mvs.execute("CN", [])[0]
+        self.var = self.mvs.execute("CN", [])
+        self.value = self.mvs.execute("CN", [])
 
-        self.inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"resolve"}])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
-        t = self.mvs.execute("CE", [self.symbols, self.value])[0]
+        t = self.mvs.execute("CE", [self.symbols, self.value])
         self.mvs.execute("CE", [t, self.var])
 
         ### Execute rules
@@ -51,14 +51,14 @@ class Testresolve(unittest.TestCase):
         """
         Test the resolution of a global variable
         """
-        self.var = self.mvs.execute("CNV", ["glob"])[0]
-        self.value = self.mvs.execute("CN", [])[0]
+        self.var = self.mvs.execute("CNV", ["glob"])
+        self.value = self.mvs.execute("CN", [])
 
-        self.inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"resolve"}])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
-        t = self.mvs.execute("CE", [self.global_task, self.value])[0]
+        t = self.mvs.execute("CE", [self.global_task, self.value])
         self.mvs.execute("CE", [t, self.var])
 
         ### Execute rules
@@ -74,17 +74,17 @@ class Testresolve(unittest.TestCase):
         """
         Test the resolution of a local variable over a global
         """
-        self.var = self.mvs.execute("CNV", ["local"])[0]
-        self.global_value = self.mvs.execute("CN", [])[0]
-        self.local_value = self.mvs.execute("CN", [])[0]
+        self.var = self.mvs.execute("CNV", ["local"])
+        self.global_value = self.mvs.execute("CN", [])
+        self.local_value = self.mvs.execute("CN", [])
 
-        self.inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"resolve"}])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
-        t = self.mvs.execute("CE", [self.global_task, self.global_value])[0]
+        t = self.mvs.execute("CE", [self.global_task, self.global_value])
         self.mvs.execute("CE", [t, self.var])
-        t = self.mvs.execute("CE", [self.symbols, self.local_value])[0]
+        t = self.mvs.execute("CE", [self.symbols, self.local_value])
         self.mvs.execute("CE", [t, self.var])
 
         ### Execute rules

kernel/test/instructions/test_instruction_return.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class Testreturn(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -27,12 +27,12 @@ class Testreturn(unittest.TestCase):
         Test the code:
             return True
         """
-        prev_task_frame = self.mvs.execute("CN", [])[0]
-        prev_symbols = self.mvs.execute("CN", [])[0]
-        prev_evalstack = self.mvs.execute("CN", [])[0]
-        prev_returnvalue = self.mvs.execute("CN", [])[0]
-        prev_phase = self.mvs.execute("CNV", ["init"])[0]
-        prev_IP = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        prev_task_frame = self.mvs.execute("CN", [])
+        prev_symbols = self.mvs.execute("CN", [])
+        prev_evalstack = self.mvs.execute("CN", [])
+        prev_returnvalue = self.mvs.execute("CN", [])
+        prev_phase = self.mvs.execute("CNV", ["init"])
+        prev_IP = self.mvs.execute("CNV", [{"value":"constant"}])
 
         self.mvs.execute("CD", [self.task_frame, "prev", prev_task_frame])
         self.mvs.execute("CD", [prev_task_frame, "symbols", prev_symbols])
@@ -41,9 +41,9 @@ class Testreturn(unittest.TestCase):
         self.mvs.execute("CD", [prev_task_frame, "IP", prev_IP])
         self.mvs.execute("CD", [prev_task_frame, "returnvalue", prev_returnvalue])
 
-        self.inst = self.mvs.execute("CNV", [{"value":"return"}])[0]
-        self.const_true = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_true = self.mvs.execute("CNV", [True])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"return"}])
+        self.const_true = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_true = self.mvs.execute("CNV", [True])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "value", self.const_true])
@@ -71,6 +71,6 @@ class Testreturn(unittest.TestCase):
         self.assertEquals(get_phase(self.root, self.mvs), "init")
         self.assertEquals(get_returnvalue(self.root, self.mvs), True)
 
-        t = self.mvs.execute("RD", [self.root, "task_1"])[0]
-        t = self.mvs.execute("RD", [t, "frame"])[0]
+        t = self.mvs.execute("RD", [self.root, "task_1"])
+        t = self.mvs.execute("RD", [t, "frame"])
         self.assertEquals(t, prev_task_frame)

kernel/test/instructions/test_instruction_while.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class Testwhile(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -29,15 +29,15 @@ class Testwhile(unittest.TestCase):
                 a
             b
         """
-        self.inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"while"}])
 
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_cond = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_cond = self.mvs.execute("CNV", [{"value":"constant"}])
 
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_cond = self.mvs.execute("CNV", [True])[0]
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_cond = self.mvs.execute("CNV", [True])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_cond])
@@ -136,15 +136,15 @@ class Testwhile(unittest.TestCase):
                 a
             b
         """
-        self.inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"while"}])
 
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_cond = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_cond = self.mvs.execute("CNV", [{"value":"constant"}])
 
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_cond = self.mvs.execute("CNV", [False])[0]
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_cond = self.mvs.execute("CNV", [False])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_cond])
@@ -192,15 +192,15 @@ class Testwhile(unittest.TestCase):
             b
         But where the True changes to a False after 2 iterations
         """
-        self.inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"while"}])
 
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_cond = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_cond = self.mvs.execute("CNV", [{"value":"constant"}])
 
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_cond = self.mvs.execute("CNV", [True])[0]
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_cond = self.mvs.execute("CNV", [True])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_cond])
@@ -268,7 +268,7 @@ class Testwhile(unittest.TestCase):
         # Modify the constant to force the loop to stop
         #####
 
-        new_const_cond = self.mvs.execute("CNV", [False])[0]
+        new_const_cond = self.mvs.execute("CNV", [False])
         self.mvs.execute("DN", [self.value_cond])
         self.mvs.execute("CD", [self.const_cond, "node", new_const_cond])
 

kernel/test/instructions/utils.py

@@ -32,21 +32,21 @@ class MvSWrapper(object):
         retval = self.mapping[command](*params)
         retval = json.loads(json.dumps(retval))
 
-        return [retval[0]]
+        return retval
 
 def add_new_task(root, mvs, taskname):
-    hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
-    initial = mvs.execute("RD", [hierarchy, "__IP"])[0]
+    hierarchy = mvs.execute("RD", [root, "__hierarchy"])
+    initial = mvs.execute("RD", [hierarchy, "__IP"])
 
-    task_root = mvs.execute("CN", [])[0]
-    _globals = mvs.execute("CN", [])[0]
-    frame = mvs.execute("CN", [])[0]
-    evalstack = mvs.execute("CN", [])[0]
-    symbols = mvs.execute("CN", [])[0]
-    _input = mvs.execute("CN", [])[0]
-    _output = mvs.execute("CN", [])[0]
-    returnvalue = mvs.execute("CN", [])[0]
-    phase = mvs.execute("CNV", ["init"])[0]
+    task_root = mvs.execute("CN", [])
+    _globals = mvs.execute("CN", [])
+    frame = mvs.execute("CN", [])
+    evalstack = mvs.execute("CN", [])
+    symbols = mvs.execute("CN", [])
+    _input = mvs.execute("CN", [])
+    _output = mvs.execute("CN", [])
+    returnvalue = mvs.execute("CN", [])
+    phase = mvs.execute("CNV", ["init"])
 
     mvs.execute("CD", [root, taskname, task_root])
     mvs.execute("CD", [task_root, "frame", frame])
@@ -72,49 +72,49 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
             break
         response = []
         for command, param in mvs_commands:
-            response.append(mvs.execute(command, param)[0])
+            response.append(mvs.execute(command, param))
 
 def get_inst(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    inst = mvs.execute("RD", [task_frame, "IP"])[0]
-    return mvs.execute("RV", [inst])[0]["value"]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    inst = mvs.execute("RD", [task_frame, "IP"])
+    return mvs.execute("RV", [inst])["value"]
 
 def get_phase(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    phase = mvs.execute("RD", [task_frame, "phase"])[0]
-    return mvs.execute("RV", [phase])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    phase = mvs.execute("RD", [task_frame, "phase"])
+    return mvs.execute("RV", [phase])
 
 def get_returnvalue(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])[0]
-    return mvs.execute("RV", [returnvalue])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])
+    return mvs.execute("RV", [returnvalue])
 
 def get_inst_ref(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    return mvs.execute("RD", [task_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    return mvs.execute("RD", [task_frame, "IP"])
 
 def get_returnvalue_ref(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    return mvs.execute("RD", [task_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    return mvs.execute("RD", [task_frame, "returnvalue"])
 
 def get_phase_ref(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    phase = mvs.execute("RD", [task_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    phase = mvs.execute("RD", [task_frame, "phase"])
     return phase
 
 def read_primitive_interfaces(root, mvs):
-    hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
-    primitives = mvs.execute("RD", [hierarchy, "primitives"])[0]
-    keys = mvs.execute("RDK", [primitives])[0]
+    hierarchy = mvs.execute("RD", [root, "__hierarchy"])
+    primitives = mvs.execute("RD", [hierarchy, "primitives"])
+    keys = mvs.execute("RDK", [primitives])
     d = {}
     for k in keys:
-        value = mvs.execute("RDN", [primitives, k])[0]
-        name = mvs.execute("RV", [k])[0]
+        value = mvs.execute("RDN", [primitives, k])
+        name = mvs.execute("RV", [k])
         d[name] = value
     return d

kernel/test/primitives/test_action.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestAction(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -44,23 +44,23 @@ class TestAction(unittest.TestCase):
         self.helper_primitives_2_params("value_neq", {"value": "while"}, 10, True)
 
     def helper_primitives_2_params(self, operation, a, b, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CNV", [a])[0]
-        self.value_second = self.mvs.execute("CNV", [b])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CNV", [a])
+        self.value_second = self.mvs.execute("CNV", [b])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -140,20 +140,20 @@ class TestAction(unittest.TestCase):
         self.assertEquals(get_returnvalue(self.root, self.mvs), "c")
 
     def helper_primitives_1_params(self, operation, a, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CNV", [a])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CNV", [a])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/primitives/test_bool.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestBool(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -80,23 +80,23 @@ class TestBool(unittest.TestCase):
         self.helper_primitives_2_params("value_neq", False, False, False)
 
     def helper_primitives_2_params(self, operation, a, b, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CNV", [a])[0]
-        self.value_second = self.mvs.execute("CNV", [b])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CNV", [a])
+        self.value_second = self.mvs.execute("CNV", [b])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -176,20 +176,20 @@ class TestBool(unittest.TestCase):
         self.assertEquals(get_returnvalue(self.root, self.mvs), "c")
 
     def helper_primitives_1_params(self, operation, a, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CNV", [a])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CNV", [a])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/primitives/test_cast.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestCast(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -71,21 +71,21 @@ class TestCast(unittest.TestCase):
         self.helper_primitives_1_params("cast_b2s", False, "False")
 
     def test_cast_e2s_node(self):
-        n = self.mvs.execute("CN", [])[0]
+        n = self.mvs.execute("CN", [])
         self.helper_primitives_1_params("cast_e2s", n, "{ID: %s, value: None}" % n, t=True)
 
     def test_cast_e2s_edge(self):
-        a = self.mvs.execute("CN", [])[0]
-        b = self.mvs.execute("CN", [])[0]
-        n = self.mvs.execute("CE", [a, b])[0]
+        a = self.mvs.execute("CN", [])
+        b = self.mvs.execute("CN", [])
+        n = self.mvs.execute("CE", [a, b])
         self.helper_primitives_1_params("cast_e2s", n, "{ID: %s, value: None}" % n, t=True)
 
     def test_cast_e2s_value(self):
-        n = self.mvs.execute("CNV", [10])[0]
+        n = self.mvs.execute("CNV", [10])
         self.helper_primitives_1_params("cast_e2s", n, "{ID: %s, value: 10}" % n, t=True)
 
     def test_cast_v2s_int(self):
-        n = self.mvs.execute("CN", [])[0]
+        n = self.mvs.execute("CN", [])
         self.helper_primitives_1_params("cast_v2s", n, "None", t=True)
 
     def test_cast_v2s_int(self):
@@ -113,37 +113,37 @@ class TestCast(unittest.TestCase):
         self.helper_primitives_1_params("cast_v2s", {"value": "call"}, "call")
 
     def test_cast_id2s_node(self):
-        n = self.mvs.execute("CN", [])[0]
+        n = self.mvs.execute("CN", [])
         self.helper_primitives_1_params("cast_id2s", n, str(n), t=True)
 
     def test_cast_id2s_value(self):
-        n = self.mvs.execute("CNV", ["abc"])[0]
+        n = self.mvs.execute("CNV", ["abc"])
         self.helper_primitives_1_params("cast_id2s", n, str(n), t=True)
 
     def test_cast_id2s_edge(self):
-        a = self.mvs.execute("CN", [])[0]
-        b = self.mvs.execute("CN", [])[0]
-        n = self.mvs.execute("CE", [a, b])[0]
+        a = self.mvs.execute("CN", [])
+        b = self.mvs.execute("CN", [])
+        n = self.mvs.execute("CE", [a, b])
         self.helper_primitives_1_params("cast_id2s", n, str(n), t=True)
 
     def helper_primitives_1_params(self, operation, a, result, t=False):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
         if t:
             self.value_first = a
         else:
-            self.value_first = self.mvs.execute("CNV", [a])[0]
+            self.value_first = self.mvs.execute("CNV", [a])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/primitives/test_create.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestCreate(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -29,55 +29,55 @@ class TestCreate(unittest.TestCase):
         self.helper_primitives_no_params("create_node")
         v = get_returnvalue_ref(self.root, self.mvs)
         # v should be a newly created node that is unused at the moment
-        self.assertEquals(self.mvs.execute("RV", [v])[0], None)
-        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
-        self.assertEquals(len(self.mvs.execute("RO", [v])[0]), 0)
+        self.assertEquals(self.mvs.execute("RV", [v]), None)
+        self.assertEquals(self.mvs.execute("RE", [v]), [None, None])
+        self.assertEquals(len(self.mvs.execute("RO", [v])), 0)
         # There is an incoming link, as this is due to the returnvalue link
-        self.assertEquals(len(self.mvs.execute("RI", [v])[0]), 1)
+        self.assertEquals(len(self.mvs.execute("RI", [v])), 1)
 
     def test_create_edge(self):
-        a = self.mvs.execute("CN", [])[0]
-        b = self.mvs.execute("CN", [])[0]
+        a = self.mvs.execute("CN", [])
+        b = self.mvs.execute("CN", [])
         self.helper_primitives_2_params("create_edge", a, b)
         v = get_returnvalue_ref(self.root, self.mvs)
 
         # v should be a newly created edge that is unused at the moment
-        self.assertEquals(self.mvs.execute("RV", [v])[0], None)
-        self.assertEquals(self.mvs.execute("RE", [v])[0], [a, b])
-        self.assertEquals(len(self.mvs.execute("RO", [v])[0]), 0)
+        self.assertEquals(self.mvs.execute("RV", [v]), None)
+        self.assertEquals(self.mvs.execute("RE", [v]), [a, b])
+        self.assertEquals(len(self.mvs.execute("RO", [v])), 0)
         # There is an incoming link, as this is due to the returnvalue link
-        self.assertEquals(len(self.mvs.execute("RI", [v])[0]), 1)
+        self.assertEquals(len(self.mvs.execute("RI", [v])), 1)
 
     def test_create_value(self):
-        v = self.mvs.execute("CNV", [1])[0]
+        v = self.mvs.execute("CNV", [1])
         self.helper_primitives_1_params("create_value", v)
 
         v = get_returnvalue_ref(self.root, self.mvs)
         # v should be a newly created node that is unused at the moment
-        self.assertEquals(self.mvs.execute("RV", [v])[0], 1)
-        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
-        self.assertEquals(len(self.mvs.execute("RO", [v])[0]), 0)
+        self.assertEquals(self.mvs.execute("RV", [v]), 1)
+        self.assertEquals(self.mvs.execute("RE", [v]), [None, None])
+        self.assertEquals(len(self.mvs.execute("RO", [v])), 0)
         # There is an incoming link, as this is due to the returnvalue link
-        self.assertEquals(len(self.mvs.execute("RI", [v])[0]), 1)
+        self.assertEquals(len(self.mvs.execute("RI", [v])), 1)
 
     def helper_primitives_2_params(self, operation, a, b):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
         self.value_first = a
         self.value_second = b
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -147,20 +147,20 @@ class TestCreate(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
     def helper_primitives_1_params(self, operation, a):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
         self.value_first = a
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -213,17 +213,17 @@ class TestCreate(unittest.TestCase):
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
 
     def helper_primitives_no_params(self, operation):
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/primitives/test_delete.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestDelete(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -26,72 +26,72 @@ class TestDelete(unittest.TestCase):
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
 
     def test_delete_node(self):
-        v = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [a, v])[0]
+        v = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [a, v])
         self.helper_primitives_1_params("delete_element", v)
 
-        self.assertEquals(self.mvs.execute("RV", [v])[0], None)
-        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
-        self.assertEquals(self.mvs.execute("RO", [v])[0], None)
-        self.assertEquals(self.mvs.execute("RI", [v])[0], None)
+        self.assertEquals(self.mvs.execute("RV", [v]), None)
+        self.assertEquals(self.mvs.execute("RE", [v]), [None, None])
+        self.assertEquals(self.mvs.execute("RO", [v]), None)
+        self.assertEquals(self.mvs.execute("RI", [v]), None)
 
         # The edge is gone too
-        self.assertEquals(self.mvs.execute("RV", [e])[0], None)
-        self.assertEquals(self.mvs.execute("RE", [e])[0], [None, None])
-        self.assertEquals(self.mvs.execute("RO", [e])[0], None)
-        self.assertEquals(self.mvs.execute("RI", [e])[0], None)
+        self.assertEquals(self.mvs.execute("RV", [e]), None)
+        self.assertEquals(self.mvs.execute("RE", [e]), [None, None])
+        self.assertEquals(self.mvs.execute("RO", [e]), None)
+        self.assertEquals(self.mvs.execute("RI", [e]), None)
 
         # But the other node remains
-        self.assertEquals(self.mvs.execute("RV", [a])[0], None)
-        self.assertEquals(self.mvs.execute("RE", [a])[0], [None, None])
-        self.assertNotEquals(self.mvs.execute("RO", [a])[0], None)
-        self.assertNotEquals(self.mvs.execute("RI", [a])[0], None)
+        self.assertEquals(self.mvs.execute("RV", [a]), None)
+        self.assertEquals(self.mvs.execute("RE", [a]), [None, None])
+        self.assertNotEquals(self.mvs.execute("RO", [a]), None)
+        self.assertNotEquals(self.mvs.execute("RI", [a]), None)
 
         r = get_returnvalue(self.root, self.mvs)
         self.assertEquals(r, False)
 
     def test_delete_edge(self):
-        v = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [a, v])[0]
+        v = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [a, v])
         self.helper_primitives_1_params("delete_element", e)
 
         # Edge disappears
-        self.assertEquals(self.mvs.execute("RV", [e])[0], None)
-        self.assertEquals(self.mvs.execute("RE", [e])[0], [None, None])
-        self.assertEquals(self.mvs.execute("RO", [e])[0], None)
-        self.assertEquals(self.mvs.execute("RI", [e])[0], None)
+        self.assertEquals(self.mvs.execute("RV", [e]), None)
+        self.assertEquals(self.mvs.execute("RE", [e]), [None, None])
+        self.assertEquals(self.mvs.execute("RO", [e]), None)
+        self.assertEquals(self.mvs.execute("RI", [e]), None)
 
         # But the nodes remains
-        self.assertEquals(self.mvs.execute("RV", [a])[0], None)
-        self.assertEquals(self.mvs.execute("RE", [a])[0], [None, None])
-        self.assertNotEquals(self.mvs.execute("RO", [a])[0], None)
-        self.assertNotEquals(self.mvs.execute("RI", [a])[0], None)
+        self.assertEquals(self.mvs.execute("RV", [a]), None)
+        self.assertEquals(self.mvs.execute("RE", [a]), [None, None])
+        self.assertNotEquals(self.mvs.execute("RO", [a]), None)
+        self.assertNotEquals(self.mvs.execute("RI", [a]), None)
 
-        self.assertEquals(self.mvs.execute("RV", [v])[0], None)
-        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
-        self.assertNotEquals(self.mvs.execute("RO", [v])[0], None)
-        self.assertNotEquals(self.mvs.execute("RI", [v])[0], None)
+        self.assertEquals(self.mvs.execute("RV", [v]), None)
+        self.assertEquals(self.mvs.execute("RE", [v]), [None, None])
+        self.assertNotEquals(self.mvs.execute("RO", [v]), None)
+        self.assertNotEquals(self.mvs.execute("RI", [v]), None)
 
         r = get_returnvalue(self.root, self.mvs)
         self.assertEquals(r, True)
 
     def helper_primitives_1_params(self, operation, a):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
         self.value_first = a
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/primitives/test_dict.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestDict(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -71,37 +71,37 @@ class TestDict(unittest.TestCase):
 
     def construct(self, source, dct):
         for i, v in dct.items():
-            t = self.mvs.execute("CNV", [v])[0]
+            t = self.mvs.execute("CNV", [v])
             self.mvs.execute("CD", [source, i, t])
 
     def parse(self, source, expected):
         if isinstance(expected, dict):
-            self.assertEquals(len(self.mvs.execute("RO", [source])[0]), len(expected))
+            self.assertEquals(len(self.mvs.execute("RO", [source])), len(expected))
             for i, v in expected.items():
-                self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [source, i])[0]])[0], v)
+                self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [source, i])]), v)
         else:
             self.assertEquals(get_returnvalue(self.root, self.mvs), expected)
 
     def helper_primitives_2_params(self, operation, a, b, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CN", [])[0]
-        self.value_second = self.mvs.execute("CNV", [b])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CN", [])
+        self.value_second = self.mvs.execute("CNV", [b])
 
         self.construct(self.value_first, a)
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -172,20 +172,20 @@ class TestDict(unittest.TestCase):
         self.parse(self.value_first, result)
 
     def helper_primitives_1_params(self, operation, a, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CN", [])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -243,26 +243,26 @@ class TestDict(unittest.TestCase):
         self.parse(self.value_first, result)
 
     def helper_primitives_3_params(self, operation, a, b, c, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-        self.actual_arg_c = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_third = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CN", [])[0]
-        self.value_second = self.mvs.execute("CNV", [b])[0]
-        self.value_third = self.mvs.execute("CNV", [c])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+        self.actual_arg_c = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_third = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CN", [])
+        self.value_second = self.mvs.execute("CNV", [b])
+        self.value_third = self.mvs.execute("CNV", [c])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/primitives/test_dict_special.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestDictSpecials(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -26,88 +26,88 @@ class TestDictSpecials(unittest.TestCase):
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
 
     def test_read_edge(self):
-        n = self.mvs.execute("CN", [])[0]
-        v_a = self.mvs.execute("CN", [])[0]
-        k_a = self.mvs.execute("CNV", ["a"])[0]
-        edge = self.mvs.execute("CE", [n, v_a])[0]
-        self.mvs.execute("CE", [edge, k_a])[0]
-        self.helper_primitives_2_params("dict_read_edge", n, self.mvs.execute("CNV", ["a"])[0], edge)
+        n = self.mvs.execute("CN", [])
+        v_a = self.mvs.execute("CN", [])
+        k_a = self.mvs.execute("CNV", ["a"])
+        edge = self.mvs.execute("CE", [n, v_a])
+        self.mvs.execute("CE", [edge, k_a])
+        self.helper_primitives_2_params("dict_read_edge", n, self.mvs.execute("CNV", ["a"]), edge)
 
     def test_read_node(self):
-        n = self.mvs.execute("CN", [])[0]
-        v_a = self.mvs.execute("CN", [])[0]
-        k_a = self.mvs.execute("CN", [])[0]
-        edge = self.mvs.execute("CE", [n, v_a])[0]
-        self.mvs.execute("CE", [edge, k_a])[0]
+        n = self.mvs.execute("CN", [])
+        v_a = self.mvs.execute("CN", [])
+        k_a = self.mvs.execute("CN", [])
+        edge = self.mvs.execute("CE", [n, v_a])
+        self.mvs.execute("CE", [edge, k_a])
         self.helper_primitives_2_params("dict_read_node", n, k_a, v_a)
 
     def test_in_node(self):
-        n = self.mvs.execute("CN", [])[0]
-        v_a = self.mvs.execute("CN", [])[0]
-        k_a = self.mvs.execute("CN", [])[0]
-        edge = self.mvs.execute("CE", [n, v_a])[0]
-        self.mvs.execute("CE", [edge, k_a])[0]
+        n = self.mvs.execute("CN", [])
+        v_a = self.mvs.execute("CN", [])
+        k_a = self.mvs.execute("CN", [])
+        edge = self.mvs.execute("CE", [n, v_a])
+        self.mvs.execute("CE", [edge, k_a])
         self.helper_primitives_2_params("dict_in_node", n, k_a, True, is_val=True)
 
     def test_in_node_false(self):
-        n = self.mvs.execute("CN", [])[0]
-        v_a = self.mvs.execute("CN", [])[0]
-        k_a = self.mvs.execute("CN", [])[0]
-        k_a2 = self.mvs.execute("CN", [])[0]
-        edge = self.mvs.execute("CE", [n, v_a])[0]
-        self.mvs.execute("CE", [edge, k_a])[0]
+        n = self.mvs.execute("CN", [])
+        v_a = self.mvs.execute("CN", [])
+        k_a = self.mvs.execute("CN", [])
+        k_a2 = self.mvs.execute("CN", [])
+        edge = self.mvs.execute("CE", [n, v_a])
+        self.mvs.execute("CE", [edge, k_a])
         self.helper_primitives_2_params("dict_in_node", n, k_a2, False, is_val=True)
 
     def test_in_node_true(self):
-        n = self.mvs.execute("CN", [])[0]
-        v_a = self.mvs.execute("CN", [])[0]
-        k_a = self.mvs.execute("CN", [])[0]
-        edge = self.mvs.execute("CE", [n, v_a])[0]
-        self.mvs.execute("CE", [edge, k_a])[0]
+        n = self.mvs.execute("CN", [])
+        v_a = self.mvs.execute("CN", [])
+        k_a = self.mvs.execute("CN", [])
+        edge = self.mvs.execute("CE", [n, v_a])
+        self.mvs.execute("CE", [edge, k_a])
         self.helper_primitives_2_params("dict_in_node", n, k_a, True, is_val=True)
 
     def test_read_node_value(self):
-        n = self.mvs.execute("CN", [])[0]
-        v_a = self.mvs.execute("CN", [])[0]
-        k_a = self.mvs.execute("CNV", [1])[0]
-        edge = self.mvs.execute("CE", [n, v_a])[0]
-        self.mvs.execute("CE", [edge, k_a])[0]
-        self.helper_primitives_2_params("dict_read_node", n, self.mvs.execute("CNV", [1])[0], None)
+        n = self.mvs.execute("CN", [])
+        v_a = self.mvs.execute("CN", [])
+        k_a = self.mvs.execute("CNV", [1])
+        edge = self.mvs.execute("CE", [n, v_a])
+        self.mvs.execute("CE", [edge, k_a])
+        self.helper_primitives_2_params("dict_read_node", n, self.mvs.execute("CNV", [1]), None)
 
     def test_keys(self):
-        n = self.mvs.execute("CN", [])[0]
-        self.mvs.execute("CD", [n, "abc", self.mvs.execute("CNV", [1])[0]])
-        self.mvs.execute("CD", [n, "d", self.mvs.execute("CNV", ["a"])[0]])
-        self.mvs.execute("CD", [n, "123", self.mvs.execute("CNV", [True])[0]])
+        n = self.mvs.execute("CN", [])
+        self.mvs.execute("CD", [n, "abc", self.mvs.execute("CNV", [1])])
+        self.mvs.execute("CD", [n, "d", self.mvs.execute("CNV", ["a"])])
+        self.mvs.execute("CD", [n, "123", self.mvs.execute("CNV", [True])])
         self.helper_primitives_1_params("dict_keys", n, ["abc", "d", "123"])
 
     def parse(self, source, expected):
         if isinstance(expected, dict):
-            self.assertEquals(len(self.mvs.execute("RO", [source])[0]), len(expected))
+            self.assertEquals(len(self.mvs.execute("RO", [source])), len(expected))
             for i, v in expected.items():
-                self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [source, i])[0]])[0], v)
+                self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [source, i])]), v)
         else:
             self.assertEquals(get_returnvalue(self.root, self.mvs), expected)
 
     def helper_primitives_2_params(self, operation, a, b, result, is_val=False):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
 
         self.value_first = a
         self.value_second = b
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -180,21 +180,21 @@ class TestDictSpecials(unittest.TestCase):
             self.assertEquals(get_returnvalue(self.root, self.mvs), result)
 
     def helper_primitives_1_params(self, operation, a, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
 
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
 
         self.value_first = a
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -245,10 +245,10 @@ class TestDictSpecials(unittest.TestCase):
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
         
         returnval = get_returnvalue_ref(self.root, self.mvs)
-        outgoing_links = self.mvs.execute("RO", [returnval])[0]
+        outgoing_links = self.mvs.execute("RO", [returnval])
         received = []
         for l in outgoing_links:
-            src, dst = self.mvs.execute("RE", [l])[0]
-            received.append(self.mvs.execute("RV", [dst])[0])
+            src, dst = self.mvs.execute("RE", [l])
+            received.append(self.mvs.execute("RV", [dst]))
 
         self.assertEquals(sorted(received), sorted(result))

kernel/test/primitives/test_edge.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestEdge(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -26,34 +26,34 @@ class TestEdge(unittest.TestCase):
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
 
     def test_is_edge_N(self):
-        a = self.mvs.execute("CN", [])[0]
+        a = self.mvs.execute("CN", [])
         self.helper_primitives_1_params("is_edge", a, False)
 
     def test_is_edge_V(self):
-        a = self.mvs.execute("CNV", [5])[0]
+        a = self.mvs.execute("CNV", [5])
         self.helper_primitives_1_params("is_edge", a, False)
 
     def test_is_edge_E(self):
-        a = self.mvs.execute("CN", [])[0]
-        b = self.mvs.execute("CN", [])[0]
-        c = self.mvs.execute("CE", [a, b])[0]
+        a = self.mvs.execute("CN", [])
+        b = self.mvs.execute("CN", [])
+        c = self.mvs.execute("CE", [a, b])
         self.helper_primitives_1_params("is_edge", c, True)
 
     def helper_primitives_1_params(self, operation, a, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
         self.value_first = a
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/primitives/test_element.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestType(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -26,59 +26,59 @@ class TestType(unittest.TestCase):
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
 
     def test_eq_true_value(self):
-        a = self.mvs.execute("CNV", [5])[0]
+        a = self.mvs.execute("CNV", [5])
         self.helper_primitives_2_params("element_eq", a, a, True)
 
     def test_eq_true_novalue(self):
-        a = self.mvs.execute("CN", [])[0]
+        a = self.mvs.execute("CN", [])
         self.helper_primitives_2_params("element_eq", a, a, True)
 
     def test_eq_false_value(self):
-        a = self.mvs.execute("CNV", [5])[0]
-        b = self.mvs.execute("CNV", [5])[0]
+        a = self.mvs.execute("CNV", [5])
+        b = self.mvs.execute("CNV", [5])
         self.helper_primitives_2_params("element_eq", a, b, False)
 
     def test_eq_false_novalue(self):
-        a = self.mvs.execute("CN", [])[0]
-        b = self.mvs.execute("CN", [])[0]
+        a = self.mvs.execute("CN", [])
+        b = self.mvs.execute("CN", [])
         self.helper_primitives_2_params("element_eq", a, b, False)
 
     def test_neq_true_value(self):
-        a = self.mvs.execute("CNV", [5])[0]
+        a = self.mvs.execute("CNV", [5])
         self.helper_primitives_2_params("element_neq", a, a, False)
 
     def test_neq_true_novalue(self):
-        a = self.mvs.execute("CN", [])[0]
+        a = self.mvs.execute("CN", [])
         self.helper_primitives_2_params("element_neq", a, a, False)
 
     def test_neq_false_value(self):
-        a = self.mvs.execute("CNV", [5])[0]
-        b = self.mvs.execute("CNV", [5])[0]
+        a = self.mvs.execute("CNV", [5])
+        b = self.mvs.execute("CNV", [5])
         self.helper_primitives_2_params("element_neq", a, b, True)
 
     def test_neq_false_novalue(self):
-        a = self.mvs.execute("CN", [])[0]
-        b = self.mvs.execute("CN", [])[0]
+        a = self.mvs.execute("CN", [])
+        b = self.mvs.execute("CN", [])
         self.helper_primitives_2_params("element_neq", a, b, True)
 
     def helper_primitives_2_params(self, operation, a, b, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
         self.value_first = a
         self.value_second = b
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/primitives/test_float.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestInteger(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -77,23 +77,23 @@ class TestInteger(unittest.TestCase):
         self.helper_primitives_1_params("float_neg", 0.0, 0.0)
 
     def helper_primitives_2_params(self, operation, a, b, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CNV", [a])[0]
-        self.value_second = self.mvs.execute("CNV", [b])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CNV", [a])
+        self.value_second = self.mvs.execute("CNV", [b])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -173,20 +173,20 @@ class TestInteger(unittest.TestCase):
         self.assertEquals(get_returnvalue(self.root, self.mvs), "c")
 
     def helper_primitives_1_params(self, operation, a, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CNV", [a])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CNV", [a])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/primitives/test_integer.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestInteger(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -77,23 +77,23 @@ class TestInteger(unittest.TestCase):
         self.helper_primitives_1_params("integer_neg", 0, 0)
 
     def helper_primitives_2_params(self, operation, a, b, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CNV", [a])[0]
-        self.value_second = self.mvs.execute("CNV", [b])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CNV", [a])
+        self.value_second = self.mvs.execute("CNV", [b])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -173,20 +173,20 @@ class TestInteger(unittest.TestCase):
         self.assertEquals(get_returnvalue(self.root, self.mvs), "c")
 
     def helper_primitives_1_params(self, operation, a, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CNV", [a])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CNV", [a])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/primitives/test_list.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestList(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -78,37 +78,37 @@ class TestList(unittest.TestCase):
 
     def construct(self, source, lst):
         for i, v in enumerate(lst):
-            t = self.mvs.execute("CNV", [v])[0]
+            t = self.mvs.execute("CNV", [v])
             self.mvs.execute("CD", [source, i, t])
 
     def parse(self, source, expected):
         if isinstance(expected, list):
-            self.assertEquals(len(self.mvs.execute("RO", [source])[0]), len(expected))
+            self.assertEquals(len(self.mvs.execute("RO", [source])), len(expected))
             for i, v in enumerate(expected):
-                self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [source, i])[0]])[0], v)
+                self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [source, i])]), v)
         else:
             self.assertEquals(get_returnvalue(self.root, self.mvs), expected)
 
     def helper_primitives_2_params(self, operation, a, b, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CN", [])[0]
-        self.value_second = self.mvs.execute("CNV", [b])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CN", [])
+        self.value_second = self.mvs.execute("CNV", [b])
 
         self.construct(self.value_first, a)
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -180,20 +180,20 @@ class TestList(unittest.TestCase):
         self.parse(self.value_first, result)
 
     def helper_primitives_1_params(self, operation, a, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CN", [])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -250,26 +250,26 @@ class TestList(unittest.TestCase):
         self.parse(self.value_first, result)
 
     def helper_primitives_3_params(self, operation, a, b, c, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-        self.actual_arg_c = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_third = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CN", [])[0]
-        self.value_second = self.mvs.execute("CNV", [b])[0]
-        self.value_third = self.mvs.execute("CNV", [c])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+        self.actual_arg_c = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_third = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CN", [])
+        self.value_second = self.mvs.execute("CNV", [b])
+        self.value_third = self.mvs.execute("CNV", [c])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/primitives/test_read.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestRead(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -31,182 +31,182 @@ class TestRead(unittest.TestCase):
         self.assertEquals(v, self.root)
 
     def test_read_nr_out_none(self):
-        v = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [a, v])[0]
+        v = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [a, v])
         self.helper_primitives_1_params("read_nr_out", v)
 
         v = get_returnvalue_ref(self.root, self.mvs)
-        self.assertEquals(self.mvs.execute("RV", [v])[0], 0)
-        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
-        self.assertEquals(len(self.mvs.execute("RO", [v])[0]), 0)
+        self.assertEquals(self.mvs.execute("RV", [v]), 0)
+        self.assertEquals(self.mvs.execute("RE", [v]), [None, None])
+        self.assertEquals(len(self.mvs.execute("RO", [v])), 0)
         # There is an incoming link, as this is due to the returnvalue link
-        self.assertEquals(len(self.mvs.execute("RI", [v])[0]), 1)
+        self.assertEquals(len(self.mvs.execute("RI", [v])), 1)
 
     def test_read_nr_out_one(self):
-        v = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [v, a])[0]
+        v = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [v, a])
         self.helper_primitives_1_params("read_nr_out", v)
 
         v = get_returnvalue_ref(self.root, self.mvs)
-        self.assertEquals(self.mvs.execute("RV", [v])[0], 1)
-        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
-        self.assertEquals(len(self.mvs.execute("RO", [v])[0]), 0)
+        self.assertEquals(self.mvs.execute("RV", [v]), 1)
+        self.assertEquals(self.mvs.execute("RE", [v]), [None, None])
+        self.assertEquals(len(self.mvs.execute("RO", [v])), 0)
         # There is an incoming link, as this is due to the returnvalue link
-        self.assertEquals(len(self.mvs.execute("RI", [v])[0]), 1)
+        self.assertEquals(len(self.mvs.execute("RI", [v])), 1)
 
     def test_read_nr_out_multi(self):
-        v = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [v, a])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [v, a])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [v, a])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [v, a])[0]
+        v = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [v, a])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [v, a])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [v, a])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [v, a])
         self.helper_primitives_1_params("read_nr_out", v)
 
         v = get_returnvalue_ref(self.root, self.mvs)
-        self.assertEquals(self.mvs.execute("RV", [v])[0], 4)
-        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
-        self.assertEquals(len(self.mvs.execute("RO", [v])[0]), 0)
+        self.assertEquals(self.mvs.execute("RV", [v]), 4)
+        self.assertEquals(self.mvs.execute("RE", [v]), [None, None])
+        self.assertEquals(len(self.mvs.execute("RO", [v])), 0)
         # There is an incoming link, as this is due to the returnvalue link
-        self.assertEquals(len(self.mvs.execute("RI", [v])[0]), 1)
+        self.assertEquals(len(self.mvs.execute("RI", [v])), 1)
 
     def test_read_nr_in_none(self):
-        v = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [v, a])[0]
+        v = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [v, a])
         self.helper_primitives_1_params("read_nr_in", v)
 
         v = get_returnvalue_ref(self.root, self.mvs)
         # There are still input links from the execution itself, such as entries in symbol table, parameter lists, ...
-        self.assertEquals(self.mvs.execute("RV", [v])[0], 3)
-        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
-        self.assertEquals(len(self.mvs.execute("RO", [v])[0]), 0)
+        self.assertEquals(self.mvs.execute("RV", [v]), 3)
+        self.assertEquals(self.mvs.execute("RE", [v]), [None, None])
+        self.assertEquals(len(self.mvs.execute("RO", [v])), 0)
         # There is an incoming link, as this is due to the returnvalue link
-        self.assertEquals(len(self.mvs.execute("RI", [v])[0]), 1)
+        self.assertEquals(len(self.mvs.execute("RI", [v])), 1)
 
     def test_read_nr_in_one(self):
-        v = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [a, v])[0]
+        v = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [a, v])
         self.helper_primitives_1_params("read_nr_in", v)
 
         v = get_returnvalue_ref(self.root, self.mvs)
         # There are still input links from the execution itself, such as entries in symbol table, parameter lists, ...
-        self.assertEquals(self.mvs.execute("RV", [v])[0], 4)
-        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
-        self.assertEquals(len(self.mvs.execute("RO", [v])[0]), 0)
+        self.assertEquals(self.mvs.execute("RV", [v]), 4)
+        self.assertEquals(self.mvs.execute("RE", [v]), [None, None])
+        self.assertEquals(len(self.mvs.execute("RO", [v])), 0)
         # There is an incoming link, as this is due to the returnvalue link
-        self.assertEquals(len(self.mvs.execute("RI", [v])[0]), 1)
+        self.assertEquals(len(self.mvs.execute("RI", [v])), 1)
 
     def test_read_nr_in_multi(self):
-        v = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [a, v])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [a, v])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [a, v])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [a, v])[0]
+        v = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [a, v])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [a, v])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [a, v])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [a, v])
         self.helper_primitives_1_params("read_nr_in", v)
 
         v = get_returnvalue_ref(self.root, self.mvs)
         # There are still input links from the execution itself, such as entries in symbol table, parameter lists, ...
-        self.assertEquals(self.mvs.execute("RV", [v])[0], 7)
-        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
-        self.assertEquals(len(self.mvs.execute("RO", [v])[0]), 0)
+        self.assertEquals(self.mvs.execute("RV", [v]), 7)
+        self.assertEquals(self.mvs.execute("RE", [v]), [None, None])
+        self.assertEquals(len(self.mvs.execute("RO", [v])), 0)
         # There is an incoming link, as this is due to the returnvalue link
-        self.assertEquals(len(self.mvs.execute("RI", [v])[0]), 1)
+        self.assertEquals(len(self.mvs.execute("RI", [v])), 1)
 
     def test_read_out_one(self):
-        v = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [v, a])[0]
-        self.helper_primitives_2_params("read_out", v, self.mvs.execute("CNV", [0])[0])
+        v = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [v, a])
+        self.helper_primitives_2_params("read_out", v, self.mvs.execute("CNV", [0]))
 
         v = get_returnvalue_ref(self.root, self.mvs)
         self.assertEquals(v, e)
 
     def test_read_out_multi(self):
-        v = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e1 = self.mvs.execute("CE", [v, a])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e2 = self.mvs.execute("CE", [v, a])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e3 = self.mvs.execute("CE", [v, a])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e4 = self.mvs.execute("CE", [v, a])[0]
-        self.helper_primitives_2_params("read_out", v, self.mvs.execute("CNV", [2])[0])
+        v = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
+        e1 = self.mvs.execute("CE", [v, a])
+        a = self.mvs.execute("CN", [])
+        e2 = self.mvs.execute("CE", [v, a])
+        a = self.mvs.execute("CN", [])
+        e3 = self.mvs.execute("CE", [v, a])
+        a = self.mvs.execute("CN", [])
+        e4 = self.mvs.execute("CE", [v, a])
+        self.helper_primitives_2_params("read_out", v, self.mvs.execute("CNV", [2]))
 
         v = get_returnvalue_ref(self.root, self.mvs)
         self.assertEquals(v, e3)
 
     def test_read_in_one(self):
-        v = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [a, v])[0]
-        self.helper_primitives_2_params("read_in", v, self.mvs.execute("CNV", [0])[0])
+        v = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [a, v])
+        self.helper_primitives_2_params("read_in", v, self.mvs.execute("CNV", [0]))
 
         v = get_returnvalue_ref(self.root, self.mvs)
         self.assertEquals(v, e)
 
     def test_read_in_multi(self):
-        v = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e1 = self.mvs.execute("CE", [a, v])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e2 = self.mvs.execute("CE", [a, v])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e3 = self.mvs.execute("CE", [a, v])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e4 = self.mvs.execute("CE", [a, v])[0]
-        self.helper_primitives_2_params("read_in", v, self.mvs.execute("CNV", [2])[0])
+        v = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
+        e1 = self.mvs.execute("CE", [a, v])
+        a = self.mvs.execute("CN", [])
+        e2 = self.mvs.execute("CE", [a, v])
+        a = self.mvs.execute("CN", [])
+        e3 = self.mvs.execute("CE", [a, v])
+        a = self.mvs.execute("CN", [])
+        e4 = self.mvs.execute("CE", [a, v])
+        self.helper_primitives_2_params("read_in", v, self.mvs.execute("CNV", [2]))
 
         v = get_returnvalue_ref(self.root, self.mvs)
         self.assertEquals(v, e3)
 
     def test_read_edge_src(self):
-        v = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [a, v])[0]
+        v = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [a, v])
         self.helper_primitives_1_params("read_edge_src", e)
 
         r = get_returnvalue_ref(self.root, self.mvs)
         self.assertEquals(r, a)
 
     def test_read_edge_dst(self):
-        v = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
-        e = self.mvs.execute("CE", [a, v])[0]
+        v = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
+        e = self.mvs.execute("CE", [a, v])
         self.helper_primitives_1_params("read_edge_dst", e)
 
         r = get_returnvalue_ref(self.root, self.mvs)
         self.assertEquals(r, v)
 
     def helper_primitives_2_params(self, operation, a, b):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
         self.value_first = a
         self.value_second = b
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -275,20 +275,20 @@ class TestRead(unittest.TestCase):
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
 
     def helper_primitives_1_params(self, operation, a):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
         self.value_first = a
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -341,17 +341,17 @@ class TestRead(unittest.TestCase):
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
 
     def helper_primitives_no_params(self, operation, expected=None):
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/primitives/test_set.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestSet(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -54,39 +54,39 @@ class TestSet(unittest.TestCase):
 
     def construct(self, source, lst):
         for v in lst:
-            t = self.mvs.execute("CNV", [v])[0]
+            t = self.mvs.execute("CNV", [v])
             self.mvs.execute("CE", [source, t])
 
     def parse(self, source, expected):
         if isinstance(expected, set):
-            self.assertEquals(len(self.mvs.execute("RO", [source])[0]), len(expected))
+            self.assertEquals(len(self.mvs.execute("RO", [source])), len(expected))
             s = set()
-            for v in self.mvs.execute("RO", [source])[0]:
-                s.add(self.mvs.execute("RV", [self.mvs.execute("RE", [v])[0][1]])[0])
+            for v in self.mvs.execute("RO", [source]):
+                s.add(self.mvs.execute("RV", [self.mvs.execute("RE", [v])[1]]))
             self.assertEquals(s, expected)
         else:
             self.assertEquals(get_returnvalue(self.root, self.mvs), expected)
 
     def helper_primitives_2_params(self, operation, a, b, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CN", [])[0]
-        self.value_second = self.mvs.execute("CNV", [b])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CN", [])
+        self.value_second = self.mvs.execute("CNV", [b])
 
         self.construct(self.value_first, a)
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -158,20 +158,20 @@ class TestSet(unittest.TestCase):
         self.parse(self.value_first, result)
 
     def helper_primitives_1_params(self, operation, a, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CN", [])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -228,26 +228,26 @@ class TestSet(unittest.TestCase):
         self.parse(self.value_first, result)
 
     def helper_primitives_3_params(self, operation, a, b, c, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-        self.actual_arg_c = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_third = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CN", [])[0]
-        self.value_second = self.mvs.execute("CNV", [b])[0]
-        self.value_third = self.mvs.execute("CNV", [c])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+        self.actual_arg_c = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_third = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CN", [])
+        self.value_second = self.mvs.execute("CNV", [b])
+        self.value_third = self.mvs.execute("CNV", [c])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/primitives/test_set_node.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestSetNode(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -26,75 +26,75 @@ class TestSetNode(unittest.TestCase):
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
 
     def test_remove(self):
-        n = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
+        n = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
         self.mvs.execute("CE", [n, a])
-        b = self.mvs.execute("CN", [])[0]
+        b = self.mvs.execute("CN", [])
         self.mvs.execute("CE", [n, b])
-        c = self.mvs.execute("CN", [])[0]
+        c = self.mvs.execute("CN", [])
         self.mvs.execute("CE", [n, c])
         self.helper_primitives_2_params("set_remove_node", n, b, set([a, c]))
 
     def test_remove_last(self):
-        n = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
+        n = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
         self.mvs.execute("CE", [n, a])
         self.helper_primitives_2_params("set_remove_node", n, a, set([]))
 
     def test_in_T(self):
-        n = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
+        n = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
         self.mvs.execute("CE", [n, a])
-        b = self.mvs.execute("CN", [])[0]
+        b = self.mvs.execute("CN", [])
         self.mvs.execute("CE", [n, b])
-        c = self.mvs.execute("CN", [])[0]
+        c = self.mvs.execute("CN", [])
         self.mvs.execute("CE", [n, c])
         self.helper_primitives_2_params("set_in_node", n, c, True)
 
     def test_in_F(self):
-        n = self.mvs.execute("CN", [])[0]
-        a = self.mvs.execute("CN", [])[0]
+        n = self.mvs.execute("CN", [])
+        a = self.mvs.execute("CN", [])
         self.mvs.execute("CE", [n, a])
-        b = self.mvs.execute("CN", [])[0]
+        b = self.mvs.execute("CN", [])
         self.mvs.execute("CE", [n, b])
-        c = self.mvs.execute("CN", [])[0]
+        c = self.mvs.execute("CN", [])
         self.helper_primitives_2_params("set_in_node", n, c, False)
 
     def test_in_empty(self):
-        n = self.mvs.execute("CN", [])[0]
-        c = self.mvs.execute("CN", [])[0]
+        n = self.mvs.execute("CN", [])
+        c = self.mvs.execute("CN", [])
         self.helper_primitives_2_params("set_in_node", n, c, False)
 
     def parse(self, source, expected):
         if isinstance(expected, set):
-            self.assertEquals(len(self.mvs.execute("RO", [source])[0]), len(expected))
+            self.assertEquals(len(self.mvs.execute("RO", [source])), len(expected))
             s = set()
-            for v in self.mvs.execute("RO", [source])[0]:
-                s.add(self.mvs.execute("RE", [v])[0][1])
+            for v in self.mvs.execute("RO", [source]):
+                s.add(self.mvs.execute("RE", [v])[1])
             self.assertEquals(s, expected)
         else:
             self.assertEquals(get_returnvalue(self.root, self.mvs), expected)
 
     def helper_primitives_2_params(self, operation, a, b, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CN", [])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CN", [])
         self.value_second = b
 
         self.value_first = a
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/primitives/test_string.py

@@ -5,15 +5,15 @@ from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_r
 class TestString(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
-        self.task_root = self.mvs.execute("CN", [])[0]
-        self.task_frame = self.mvs.execute("CN", [])[0]
-        self.symbols = self.mvs.execute("CN", [])[0]
-        self.evalstack = self.mvs.execute("CN", [])[0]
-        self.returnvalue = self.mvs.execute("CN", [])[0]
-        self.phase = self.mvs.execute("CNV", ["init"])[0]
+        self.task_root = self.mvs.execute("CN", [])
+        self.task_frame = self.mvs.execute("CN", [])
+        self.symbols = self.mvs.execute("CN", [])
+        self.evalstack = self.mvs.execute("CN", [])
+        self.returnvalue = self.mvs.execute("CN", [])
+        self.phase = self.mvs.execute("CNV", ["init"])
 
         self.mvs.execute("CD", [self.root, "task_1", self.task_root])
         self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
@@ -89,23 +89,23 @@ class TestString(unittest.TestCase):
         self.helper_primitives_2_params("string_split", "abc;defg;;hij", ";", ["abc", "defg", "", "hij"])
 
     def helper_primitives_2_params(self, operation, a, b, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CNV", [a])[0]
-        self.value_second = self.mvs.execute("CNV", [b])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CNV", [a])
+        self.value_second = self.mvs.execute("CNV", [b])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -176,7 +176,7 @@ class TestString(unittest.TestCase):
         if isinstance(result, list):
             ref = get_returnvalue_ref(self.root, self.mvs)
             for i, v in enumerate(result):
-                self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [ref, i])[0]])[0], v)
+                self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [ref, i])]), v)
         else:
             self.assertEquals(get_returnvalue(self.root, self.mvs), result)
         execute_until_finished(self.mvk, self.mvs)
@@ -190,20 +190,20 @@ class TestString(unittest.TestCase):
         self.assertEquals(get_returnvalue(self.root, self.mvs), "c")
 
     def helper_primitives_1_params(self, operation, a, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CNV", [a])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CNV", [a])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -266,26 +266,26 @@ class TestString(unittest.TestCase):
         self.assertEquals(get_returnvalue(self.root, self.mvs), "c")
 
     def helper_primitives_3_params(self, operation, a, b, c, result):
-        self.actual_arg_a = self.mvs.execute("CN", [])[0]
-        self.actual_arg_b = self.mvs.execute("CN", [])[0]
-        self.actual_arg_c = self.mvs.execute("CN", [])[0]
-
-        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_third = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
-        self.value_c = self.mvs.execute("CNV", ["c"])[0]
-        self.value_first = self.mvs.execute("CNV", [a])[0]
-        self.value_second = self.mvs.execute("CNV", [b])[0]
-        self.value_third = self.mvs.execute("CNV", [c])[0]
+        self.actual_arg_a = self.mvs.execute("CN", [])
+        self.actual_arg_b = self.mvs.execute("CN", [])
+        self.actual_arg_c = self.mvs.execute("CN", [])
+
+        self.inst = self.mvs.execute("CNV", [{"value":"call"}])
+        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.const_third = self.mvs.execute("CNV", [{"value":"constant"}])
+        self.value_a = self.mvs.execute("CNV", ["a"])
+        self.value_b = self.mvs.execute("CNV", ["b"])
+        self.value_c = self.mvs.execute("CNV", ["c"])
+        self.value_first = self.mvs.execute("CNV", [a])
+        self.value_second = self.mvs.execute("CNV", [b])
+        self.value_third = self.mvs.execute("CNV", [c])
 
         self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
+        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/primitives/utils.py

@@ -32,21 +32,21 @@ class MvSWrapper(object):
         retval = self.mapping[command](*params)
         retval = json.loads(json.dumps(retval))
 
-        return [retval[0]]
+        return retval
 
 def add_new_task(root, mvs, taskname):
-    hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
-    initial = mvs.execute("RD", [hierarchy, "__IP"])[0]
+    hierarchy = mvs.execute("RD", [root, "__hierarchy"])
+    initial = mvs.execute("RD", [hierarchy, "__IP"])
 
-    task_root = mvs.execute("CN", [])[0]
-    _globals = mvs.execute("CN", [])[0]
-    frame = mvs.execute("CN", [])[0]
-    evalstack = mvs.execute("CN", [])[0]
-    symbols = mvs.execute("CN", [])[0]
-    _input = mvs.execute("CN", [])[0]
-    _output = mvs.execute("CN", [])[0]
-    returnvalue = mvs.execute("CN", [])[0]
-    phase = mvs.execute("CNV", ["init"])[0]
+    task_root = mvs.execute("CN", [])
+    _globals = mvs.execute("CN", [])
+    frame = mvs.execute("CN", [])
+    evalstack = mvs.execute("CN", [])
+    symbols = mvs.execute("CN", [])
+    _input = mvs.execute("CN", [])
+    _output = mvs.execute("CN", [])
+    returnvalue = mvs.execute("CN", [])
+    phase = mvs.execute("CNV", ["init"])
 
     mvs.execute("CD", [root, taskname, task_root])
     mvs.execute("CD", [task_root, "frame", frame])
@@ -72,49 +72,49 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
             break
         response = []
         for command, param in mvs_commands:
-            response.append(mvs.execute(command, param)[0])
+            response.append(mvs.execute(command, param))
 
 def get_inst(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    inst = mvs.execute("RD", [task_frame, "IP"])[0]
-    return mvs.execute("RV", [inst])[0]["value"]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    inst = mvs.execute("RD", [task_frame, "IP"])
+    return mvs.execute("RV", [inst])["value"]
 
 def get_phase(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    phase = mvs.execute("RD", [task_frame, "phase"])[0]
-    return mvs.execute("RV", [phase])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    phase = mvs.execute("RD", [task_frame, "phase"])
+    return mvs.execute("RV", [phase])
 
 def get_returnvalue(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])[0]
-    return mvs.execute("RV", [returnvalue])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])
+    return mvs.execute("RV", [returnvalue])
 
 def get_inst_ref(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    return mvs.execute("RD", [task_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    return mvs.execute("RD", [task_frame, "IP"])
 
 def get_returnvalue_ref(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    return mvs.execute("RD", [task_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    return mvs.execute("RD", [task_frame, "returnvalue"])
 
 def get_phase_ref(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    phase = mvs.execute("RD", [task_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    phase = mvs.execute("RD", [task_frame, "phase"])
     return phase
 
 def read_primitive_interfaces(root, mvs):
-    hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
-    primitives = mvs.execute("RD", [hierarchy, "primitives"])[0]
-    keys = mvs.execute("RDK", [primitives])[0]
+    hierarchy = mvs.execute("RD", [root, "__hierarchy"])
+    primitives = mvs.execute("RD", [hierarchy, "primitives"])
+    keys = mvs.execute("RDK", [primitives])
     d = {}
     for k in keys:
-        value = mvs.execute("RDN", [primitives, k])[0]
-        name = mvs.execute("RV", [k])[0]
+        value = mvs.execute("RDN", [primitives, k])
+        name = mvs.execute("RV", [k])
         d[name] = value
     return d

kernel/test/rules/test_rules_access.py

@@ -5,17 +5,17 @@ from utils import execute_until_finished, MvSWrapper
 class Testaccess(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
     def test_access_init(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        var_inst = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"access"}])
+        evalstack = self.mvs.execute("CN", [])
+        var_inst = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -28,24 +28,24 @@ class Testaccess(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], var_inst)
-        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), var_inst)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])
         self.assertNotEquals(evalstack, new_evalstack)
-        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "eval")
+        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"]), evalstack)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])]), "eval")
 
     def test_access_eval(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["eval"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"access"}])[0]
-        value = self.mvs.execute("CN", [])[0]
-        returnvalue = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["eval"])
+        inst = self.mvs.execute("CNV", [{"value":"access"}])
+        value = self.mvs.execute("CN", [])
+        returnvalue = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -58,8 +58,8 @@ class Testaccess(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], value)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"]), value)

kernel/test/rules/test_rules_assign.py

@@ -5,17 +5,17 @@ from utils import execute_until_finished, MvSWrapper
 class TestAssign(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
     def test_assign_init(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"assign"}])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        var_inst = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"assign"}])
+        evalstack = self.mvs.execute("CN", [])
+        var_inst = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -28,25 +28,25 @@ class TestAssign(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], var_inst)
-        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), var_inst)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])
         self.assertNotEquals(evalstack, new_evalstack)
-        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "value")
+        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"]), evalstack)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])]), "value")
 
     def test_assign_value(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["value"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"assign"}])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        returnvalue = self.mvs.execute("CN", [])[0]
-        value_inst = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["value"])
+        inst = self.mvs.execute("CNV", [{"value":"assign"}])
+        evalstack = self.mvs.execute("CN", [])
+        returnvalue = self.mvs.execute("CN", [])
+        value_inst = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -60,28 +60,28 @@ class TestAssign(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], value_inst)
-        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), value_inst)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])
         self.assertNotEquals(evalstack, new_evalstack)
-        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], returnvalue)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "variable"])[0], returnvalue)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "assign")
+        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"]), evalstack)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"]), returnvalue)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "variable"]), returnvalue)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])]), "assign")
 
     def test_assign_assign(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["assign"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"assign"}])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        returnvalue = self.mvs.execute("CN", [])[0]
-        variable = self.mvs.execute("CN", [])[0]
-        value_inst = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["assign"])
+        inst = self.mvs.execute("CNV", [{"value":"assign"}])
+        evalstack = self.mvs.execute("CN", [])
+        returnvalue = self.mvs.execute("CN", [])
+        variable = self.mvs.execute("CN", [])
+        value_inst = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -96,10 +96,10 @@ class TestAssign(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "variable"])[0], None)
-        self.assertEquals(self.mvs.execute("RD", [variable, "value"])[0], returnvalue)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], returnvalue)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "variable"]), None)
+        self.assertEquals(self.mvs.execute("RD", [variable, "value"]), returnvalue)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"]), returnvalue)

kernel/test/rules/test_rules_break.py

@@ -5,20 +5,20 @@ from utils import execute_until_finished, MvSWrapper
 class Testbreak(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
     def test_basic(self):
         # Create a break construct
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"break"}])[0]
-        while_inst = self.mvs.execute("CNV", ["while"])[0]
-        evalstack_top = self.mvs.execute("CN", [])[0]
-        evalstack_bottom = self.mvs.execute("CN", [])[0]
-        finish_phase = self.mvs.execute("CNV", ["finish"])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"break"}])
+        while_inst = self.mvs.execute("CNV", ["while"])
+        evalstack_top = self.mvs.execute("CN", [])
+        evalstack_bottom = self.mvs.execute("CN", [])
+        finish_phase = self.mvs.execute("CNV", ["finish"])
 
         self.mvs.execute("CD", [task_frame, "evalstack", evalstack_top])
         self.mvs.execute("CD", [evalstack_top, "prev", evalstack_bottom])
@@ -34,9 +34,9 @@ class Testbreak(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [inst, "while"])[0], while_inst)
-        self.assertNotEquals(self.mvs.execute("RD", [task_frame, "evalstack"])[0], evalstack_top)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [inst, "while"]), while_inst)
+        self.assertNotEquals(self.mvs.execute("RD", [task_frame, "evalstack"]), evalstack_top)

kernel/test/rules/test_rules_call.py

@@ -5,22 +5,22 @@ from utils import execute_until_finished, MvSWrapper
 class Testcall(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
     def test_call_resolve_none(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        func = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"call"}])
+        evalstack = self.mvs.execute("CN", [])
+        func = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
         self.mvs.execute("CD", [task_frame, "phase", phase])
-        self.mvs.execute("CD", [task_frame, "symbols", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "symbols", self.mvs.execute("CN", [])])
         self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "func", func])
         self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
@@ -29,31 +29,31 @@ class Testcall(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], func)
-        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), func)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])
         self.assertNotEquals(evalstack, new_evalstack)
-        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "call")
+        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"]), evalstack)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])]), "call")
 
     def test_call_resolve_params(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        func = self.mvs.execute("CN", [])[0]
-        params = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"call"}])
+        evalstack = self.mvs.execute("CN", [])
+        func = self.mvs.execute("CN", [])
+        params = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
         self.mvs.execute("CD", [task_frame, "phase", phase])
         self.mvs.execute("CD", [task_frame, "IP", inst])
-        self.mvs.execute("CD", [task_frame, "symbols", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "symbols", self.mvs.execute("CN", [])])
         self.mvs.execute("CD", [inst, "func", func])
         self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [inst, "params", params])
@@ -62,30 +62,30 @@ class Testcall(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], func)
-        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), func)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])
         self.assertNotEquals(evalstack, new_evalstack)
-        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "phase"])[0], params)
+        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"]), evalstack)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "phase"]), params)
 
     def test_call_execute_none(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["call"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        returnvalue = self.mvs.execute("CN", [])[0]
-        body = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["call"])
+        inst = self.mvs.execute("CNV", [{"value":"call"}])
+        returnvalue = self.mvs.execute("CN", [])
+        body = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
         self.mvs.execute("CD", [task_frame, "phase", phase])
         self.mvs.execute("CD", [task_frame, "IP", inst])
-        self.mvs.execute("CD", [task_frame, "symbols", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "symbols", self.mvs.execute("CN", [])])
         self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [returnvalue, "body", body])
 
@@ -93,44 +93,44 @@ class Testcall(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
-        new_frame = self.mvs.execute("RD", [task_root, "frame"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), inst)
+        new_frame = self.mvs.execute("RD", [task_root, "frame"])
         self.assertNotEquals(new_frame, None)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], new_frame)
-        new_evalstack = self.mvs.execute("RD", [new_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), new_frame)
+        new_evalstack = self.mvs.execute("RD", [new_frame, "evalstack"])
         self.assertNotEquals(new_evalstack, None)
-        new_symbols = self.mvs.execute("RD", [new_frame, "symbols"])[0]
+        new_symbols = self.mvs.execute("RD", [new_frame, "symbols"])
         self.assertNotEquals(new_symbols, None)
-        new_returnvalue = self.mvs.execute("RD", [new_frame, "returnvalue"])[0]
+        new_returnvalue = self.mvs.execute("RD", [new_frame, "returnvalue"])
         self.assertNotEquals(new_returnvalue, None)
-        new_caller = self.mvs.execute("RD", [new_frame, "caller"])[0]
+        new_caller = self.mvs.execute("RD", [new_frame, "caller"])
         self.assertNotEquals(new_caller, None)
-        new_phase = self.mvs.execute("RD", [new_frame, "phase"])[0]
+        new_phase = self.mvs.execute("RD", [new_frame, "phase"])
         self.assertNotEquals(new_phase, None)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [new_frame, "phase"])[0]])[0], "init")
-        new_IP = self.mvs.execute("RD", [new_frame, "IP"])[0]
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [new_frame, "phase"])]), "init")
+        new_IP = self.mvs.execute("RD", [new_frame, "IP"])
         self.assertNotEquals(new_IP, None)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "IP"])[0], body)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "IP"]), body)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"]), task_frame)
 
     def test_call_execute_params(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["call"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        returnvalue = self.mvs.execute("CN", [])[0]
-        body = self.mvs.execute("CN", [])[0]
-        new_frame = self.mvs.execute("CN", [])[0]
-        symbols = self.mvs.execute("CN", [])[0]
-        signature = self.mvs.execute("CN", [])[0]
-        params = self.mvs.execute("CN", [])[0]
-        name = self.mvs.execute("CNV", ["param_a"])[0]
-        last_param = self.mvs.execute("CN", [])[0]
-        formal_parameter = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["call"])
+        inst = self.mvs.execute("CNV", [{"value":"call"}])
+        returnvalue = self.mvs.execute("CN", [])
+        body = self.mvs.execute("CN", [])
+        new_frame = self.mvs.execute("CN", [])
+        symbols = self.mvs.execute("CN", [])
+        signature = self.mvs.execute("CN", [])
+        params = self.mvs.execute("CN", [])
+        name = self.mvs.execute("CNV", ["param_a"])
+        last_param = self.mvs.execute("CN", [])
+        formal_parameter = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -146,37 +146,37 @@ class Testcall(unittest.TestCase):
         self.mvs.execute("CD", [inst, "last_param", last_param])
         self.mvs.execute("CD", [last_param, "name", name])
 
-        t1 = self.mvs.execute("CE", [params, formal_parameter])[0]
+        t1 = self.mvs.execute("CE", [params, formal_parameter])
         self.mvs.execute("CE", [t1, name])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], new_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
-        new_frame = self.mvs.execute("RD", [task_root, "frame"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), new_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), inst)
+        new_frame = self.mvs.execute("RD", [task_root, "frame"])
         self.assertNotEquals(new_frame, None)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "IP"])[0], body)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "IP"]), body)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"]), task_frame)
 
     def test_call_param_first_multi(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        returnvalue = self.mvs.execute("CN", [])[0]
-        body = self.mvs.execute("CN", [])[0]
-        new_frame = self.mvs.execute("CN", [])[0]
-        symbols = self.mvs.execute("CN", [])[0]
-        signature = self.mvs.execute("CN", [])[0]
-        params = self.mvs.execute("CN", [])[0]
-        param_value = self.mvs.execute("CN", [])[0]
-        next_param = self.mvs.execute("CN", [])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        inst = self.mvs.execute("CNV", [{"value":"call"}])
+        returnvalue = self.mvs.execute("CN", [])
+        body = self.mvs.execute("CN", [])
+        new_frame = self.mvs.execute("CN", [])
+        symbols = self.mvs.execute("CN", [])
+        signature = self.mvs.execute("CN", [])
+        params = self.mvs.execute("CN", [])
+        param_value = self.mvs.execute("CN", [])
+        next_param = self.mvs.execute("CN", [])
+        evalstack = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -186,7 +186,7 @@ class Testcall(unittest.TestCase):
         self.mvs.execute("CD", [signature, "body", body])
         self.mvs.execute("CD", [signature, "params", params])
         self.mvs.execute("CD", [inst, "params", params])
-        self.mvs.execute("CD", [inst, "last_param", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [inst, "last_param", self.mvs.execute("CN", [])])
         self.mvs.execute("CD", [params, "next_param", next_param])
         self.mvs.execute("CD", [params, "value", param_value])
         self.mvs.execute("CD", [returnvalue, "body", body])
@@ -196,43 +196,44 @@ class Testcall(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        new_frame = self.mvs.execute("RRD", [task_frame, "prev"])[0][0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        new_frame = self.mvs.execute("RRD", [task_frame, "prev"])
         self.assertNotEquals(new_frame, None)
-        new_evalstack = self.mvs.execute("RD", [new_frame, "evalstack"])[0]
+        new_frame = new_frame[0]
+        new_evalstack = self.mvs.execute("RD", [new_frame, "evalstack"])
         self.assertNotEquals(new_evalstack, None)
-        new_symbols = self.mvs.execute("RD", [new_frame, "symbols"])[0]
+        new_symbols = self.mvs.execute("RD", [new_frame, "symbols"])
         self.assertNotEquals(new_symbols, None)
-        new_returnvalue = self.mvs.execute("RD", [new_frame, "returnvalue"])[0]
+        new_returnvalue = self.mvs.execute("RD", [new_frame, "returnvalue"])
         self.assertNotEquals(new_returnvalue, None)
-        new_caller = self.mvs.execute("RD", [new_frame, "caller"])[0]
+        new_caller = self.mvs.execute("RD", [new_frame, "caller"])
         self.assertNotEquals(new_caller, None)
-        new_phase = self.mvs.execute("RD", [new_frame, "phase"])[0]
+        new_phase = self.mvs.execute("RD", [new_frame, "phase"])
         self.assertNotEquals(new_phase, None)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [new_frame, "phase"])[0]])[0], "init")
-        new_IP = self.mvs.execute("RD", [new_frame, "IP"])[0]
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [new_frame, "phase"])]), "init")
+        new_IP = self.mvs.execute("RD", [new_frame, "IP"])
         self.assertNotEquals(new_IP, None)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], param_value)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "phase"])[0], next_param)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), param_value)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"]), task_frame)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "phase"]), next_param)
 
     def test_call_param_first_single(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        returnvalue = self.mvs.execute("CN", [])[0]
-        body = self.mvs.execute("CN", [])[0]
-        new_frame = self.mvs.execute("CN", [])[0]
-        symbols = self.mvs.execute("CN", [])[0]
-        signature = self.mvs.execute("CN", [])[0]
-        params = self.mvs.execute("CN", [])[0]
-        param_value = self.mvs.execute("CN", [])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        inst = self.mvs.execute("CNV", [{"value":"call"}])
+        returnvalue = self.mvs.execute("CN", [])
+        body = self.mvs.execute("CN", [])
+        new_frame = self.mvs.execute("CN", [])
+        symbols = self.mvs.execute("CN", [])
+        signature = self.mvs.execute("CN", [])
+        params = self.mvs.execute("CN", [])
+        param_value = self.mvs.execute("CN", [])
+        evalstack = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -250,52 +251,53 @@ class Testcall(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        new_frame = self.mvs.execute("RRD", [task_frame, "prev"])[0][0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        new_frame = self.mvs.execute("RRD", [task_frame, "prev"])
         self.assertNotEquals(new_frame, None)
-        new_evalstack = self.mvs.execute("RD", [new_frame, "evalstack"])[0]
+        new_frame = new_frame[0]
+        new_evalstack = self.mvs.execute("RD", [new_frame, "evalstack"])
         self.assertNotEquals(new_evalstack, None)
-        new_symbols = self.mvs.execute("RD", [new_frame, "symbols"])[0]
+        new_symbols = self.mvs.execute("RD", [new_frame, "symbols"])
         self.assertNotEquals(new_symbols, None)
-        new_returnvalue = self.mvs.execute("RD", [new_frame, "returnvalue"])[0]
+        new_returnvalue = self.mvs.execute("RD", [new_frame, "returnvalue"])
         self.assertNotEquals(new_returnvalue, None)
-        new_caller = self.mvs.execute("RD", [new_frame, "caller"])[0]
+        new_caller = self.mvs.execute("RD", [new_frame, "caller"])
         self.assertNotEquals(new_caller, None)
-        new_phase = self.mvs.execute("RD", [new_frame, "phase"])[0]
+        new_phase = self.mvs.execute("RD", [new_frame, "phase"])
         self.assertNotEquals(new_phase, None)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [new_frame, "phase"])[0]])[0], "init")
-        new_IP = self.mvs.execute("RD", [new_frame, "IP"])[0]
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [new_frame, "phase"])]), "init")
+        new_IP = self.mvs.execute("RD", [new_frame, "IP"])
         self.assertNotEquals(new_IP, None)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], param_value)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "call")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), param_value)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"]), task_frame)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])]), "call")
 
-        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])
         self.assertNotEquals(evalstack, new_evalstack)
-        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"]), evalstack)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
 
     def test_params_last(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        returnvalue = self.mvs.execute("CN", [])[0]
-        body = self.mvs.execute("CN", [])[0]
-        new_frame = self.mvs.execute("CN", [])[0]
-        symbols = self.mvs.execute("CN", [])[0]
-        signature = self.mvs.execute("CN", [])[0]
-        params = self.mvs.execute("CN", [])[0]
-        param_value = self.mvs.execute("CN", [])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        last_param = self.mvs.execute("CN", [])[0]
-        prev_param = self.mvs.execute("CN", [])[0]
-        formal_parameter = self.mvs.execute("CN", [])[0]
-        formal_parameter_name = self.mvs.execute("CNV", ["param_a"])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        inst = self.mvs.execute("CNV", [{"value":"call"}])
+        returnvalue = self.mvs.execute("CN", [])
+        body = self.mvs.execute("CN", [])
+        new_frame = self.mvs.execute("CN", [])
+        symbols = self.mvs.execute("CN", [])
+        signature = self.mvs.execute("CN", [])
+        params = self.mvs.execute("CN", [])
+        param_value = self.mvs.execute("CN", [])
+        evalstack = self.mvs.execute("CN", [])
+        last_param = self.mvs.execute("CN", [])
+        prev_param = self.mvs.execute("CN", [])
+        formal_parameter = self.mvs.execute("CN", [])
+        formal_parameter_name = self.mvs.execute("CNV", ["param_a"])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -315,52 +317,52 @@ class Testcall(unittest.TestCase):
         self.mvs.execute("CD", [prev_param, "next_param", last_param])
         self.mvs.execute("CD", [prev_param, "name", formal_parameter_name])
         self.mvs.execute("CD", [last_param, "value", param_value])
-        t1 = self.mvs.execute("CE", [params, formal_parameter])[0]
-        self.mvs.execute("CE", [t1, formal_parameter_name])[0]
+        t1 = self.mvs.execute("CE", [params, formal_parameter])
+        self.mvs.execute("CE", [t1, formal_parameter_name])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], param_value)
-        var = self.mvs.execute("RDN", [symbols, formal_parameter])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), param_value)
+        var = self.mvs.execute("RDN", [symbols, formal_parameter])
         self.assertNotEquals(var, None)
-        self.assertEquals(self.mvs.execute("RD", [var, "value"])[0], returnvalue)
-        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [var, "value"]), returnvalue)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])
         self.assertNotEquals(evalstack, new_evalstack)
-        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "call")
+        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"]), evalstack)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])]), "call")
 
     def test_params_next(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
-        returnvalue = self.mvs.execute("CN", [])[0]
-        body = self.mvs.execute("CN", [])[0]
-        new_frame = self.mvs.execute("CN", [])[0]
-        symbols = self.mvs.execute("CN", [])[0]
-        signature = self.mvs.execute("CN", [])[0]
-        params = self.mvs.execute("CN", [])[0]
-        param_value = self.mvs.execute("CN", [])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        formal_parameter = self.mvs.execute("CN", [])[0]
-        formal_parameter_name = self.mvs.execute("CNV", ["param_a"])[0]
-
-        param_a = self.mvs.execute("CN", [])[0]
-        param_b = self.mvs.execute("CN", [])[0]
-        param_c = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        inst = self.mvs.execute("CNV", [{"value":"call"}])
+        returnvalue = self.mvs.execute("CN", [])
+        body = self.mvs.execute("CN", [])
+        new_frame = self.mvs.execute("CN", [])
+        symbols = self.mvs.execute("CN", [])
+        signature = self.mvs.execute("CN", [])
+        params = self.mvs.execute("CN", [])
+        param_value = self.mvs.execute("CN", [])
+        evalstack = self.mvs.execute("CN", [])
+        formal_parameter = self.mvs.execute("CN", [])
+        formal_parameter_name = self.mvs.execute("CNV", ["param_a"])
+
+        param_a = self.mvs.execute("CN", [])
+        param_b = self.mvs.execute("CN", [])
+        param_c = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
         self.mvs.execute("CD", [task_frame, "phase", param_b])
         self.mvs.execute("CD", [task_frame, "IP", inst])
-        self.mvs.execute("CD", [inst, "params", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [inst, "last_param", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [inst, "params", self.mvs.execute("CN", [])])
+        self.mvs.execute("CD", [inst, "last_param", self.mvs.execute("CN", [])])
         self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [params, "value", param_value])
         self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
@@ -374,22 +376,22 @@ class Testcall(unittest.TestCase):
         self.mvs.execute("CD", [param_b, "value", param_value])
         self.mvs.execute("CD", [param_a, "next_param", param_b])
         self.mvs.execute("CD", [param_b, "next_param", param_c])
-        t1 = self.mvs.execute("CE", [params, formal_parameter])[0]
-        self.mvs.execute("CE", [t1, formal_parameter_name])[0]
+        t1 = self.mvs.execute("CE", [params, formal_parameter])
+        self.mvs.execute("CE", [t1, formal_parameter_name])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], param_value)
-        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), param_value)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])
         self.assertNotEquals(evalstack, new_evalstack)
-        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "phase"])[0], param_c)
-        var = self.mvs.execute("RDN", [symbols, formal_parameter])[0]
+        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"]), evalstack)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "phase"]), param_c)
+        var = self.mvs.execute("RDN", [symbols, formal_parameter])
         self.assertNotEquals(var, None)
-        self.assertEquals(self.mvs.execute("RD", [var, "value"])[0], returnvalue)
+        self.assertEquals(self.mvs.execute("RD", [var, "value"]), returnvalue)

kernel/test/rules/test_rules_constant.py

@@ -5,17 +5,17 @@ from utils import execute_until_finished, MvSWrapper
 class Testconstant(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
     def test_constant(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        node = self.mvs.execute("CN", [])[0]
-        returnvalue = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"constant"}])
+        node = self.mvs.execute("CN", [])
+        returnvalue = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -28,8 +28,8 @@ class Testconstant(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [inst, "node"])[0], node)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], node)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "finish")
+        self.assertEquals(self.mvs.execute("RD", [inst, "node"]), node)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"]), node)

kernel/test/rules/test_rules_continue.py

@@ -5,20 +5,20 @@ from utils import execute_until_finished, MvSWrapper
 class Testcontinue(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
     def test_basic(self):
         # Create a continue construct
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"continue"}])[0]
-        while_inst = self.mvs.execute("CNV", ["while"])[0]
-        evalstack_top = self.mvs.execute("CN", [])[0]
-        evalstack_bottom = self.mvs.execute("CN", [])[0]
-        init_phase = self.mvs.execute("CNV", ["finish"])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"continue"}])
+        while_inst = self.mvs.execute("CNV", ["while"])
+        evalstack_top = self.mvs.execute("CN", [])
+        evalstack_bottom = self.mvs.execute("CN", [])
+        init_phase = self.mvs.execute("CNV", ["finish"])
 
         self.mvs.execute("CD", [task_frame, "evalstack", evalstack_top])
         self.mvs.execute("CD", [evalstack_top, "prev", evalstack_bottom])
@@ -34,9 +34,9 @@ class Testcontinue(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command inited, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [inst, "while"])[0], while_inst)
-        self.assertNotEquals(self.mvs.execute("RD", [task_frame, "evalstack"])[0], evalstack_top)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [inst, "while"]), while_inst)
+        self.assertNotEquals(self.mvs.execute("RD", [task_frame, "evalstack"]), evalstack_top)

kernel/test/rules/test_rules_helper.py

@@ -5,16 +5,16 @@ from utils import execute_until_finished, MvSWrapper
 class TestHelper(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
     def test_next(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["finish"])[0]
-        inst = self.mvs.execute("CN", [])[0]
-        next_inst = self.mvs.execute("CNV", ["next"])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["finish"])
+        inst = self.mvs.execute("CN", [])
+        next_inst = self.mvs.execute("CNV", ["next"])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -26,22 +26,22 @@ class TestHelper(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [inst, "next"])[0], next_inst)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], next_inst)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [inst, "next"]), next_inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), next_inst)
 
     def test_evalstack(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["finish"])[0]
-        inst = self.mvs.execute("CN", [])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        prev_evalstack = self.mvs.execute("CN", [])[0]
-        evalstack_inst = self.mvs.execute("CN", [])[0]
-        evalstack_phase = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["finish"])
+        inst = self.mvs.execute("CN", [])
+        evalstack = self.mvs.execute("CN", [])
+        prev_evalstack = self.mvs.execute("CN", [])
+        evalstack_inst = self.mvs.execute("CN", [])
+        evalstack_phase = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -56,8 +56,8 @@ class TestHelper(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], evalstack_inst)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "phase"])[0], evalstack_phase)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "evalstack"])[0], prev_evalstack)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), evalstack_inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "phase"]), evalstack_phase)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "evalstack"]), prev_evalstack)

kernel/test/rules/test_rules_if.py

@@ -5,17 +5,17 @@ from utils import execute_until_finished, MvSWrapper
 class Testif(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
     def test_if_evaluate_condition(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        cond = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"if"}])
+        evalstack = self.mvs.execute("CN", [])
+        cond = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -28,25 +28,25 @@ class Testif(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], cond)
-        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), cond)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])
         self.assertNotEquals(evalstack, new_evalstack)
-        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "cond")
+        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"]), evalstack)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])]), "cond")
 
     def test_if_true(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["cond"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        returnvalue = self.mvs.execute("CNV", [True])[0]
-        then = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["cond"])
+        inst = self.mvs.execute("CNV", [{"value":"if"}])
+        evalstack = self.mvs.execute("CN", [])
+        returnvalue = self.mvs.execute("CNV", [True])
+        then = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -60,25 +60,25 @@ class Testif(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], then)
-        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), then)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])
         self.assertNotEquals(evalstack, new_evalstack)
-        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"]), evalstack)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])]), "finish")
 
     def test_if_false_else(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["cond"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        returnvalue = self.mvs.execute("CNV", [False])[0]
-        else_inst = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["cond"])
+        inst = self.mvs.execute("CNV", [{"value":"if"}])
+        evalstack = self.mvs.execute("CN", [])
+        returnvalue = self.mvs.execute("CNV", [False])
+        else_inst = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -92,24 +92,24 @@ class Testif(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], else_inst)
-        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), else_inst)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])
         self.assertNotEquals(evalstack, new_evalstack)
-        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"]), evalstack)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])]), "finish")
 
     def test_if_false_no_else(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["cond"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        returnvalue = self.mvs.execute("CNV", [False])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["cond"])
+        inst = self.mvs.execute("CNV", [{"value":"if"}])
+        evalstack = self.mvs.execute("CN", [])
+        returnvalue = self.mvs.execute("CNV", [False])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -122,7 +122,7 @@ class Testif(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), inst)

kernel/test/rules/test_rules_input.py

@@ -5,19 +5,19 @@ from utils import execute_until_finished, MvSWrapper
 class TestInput(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
     def test_input(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"input"}])[0]
-        old_retval = self.mvs.execute("CN", [])[0]
-        input_queue_first = self.mvs.execute("CN", [])[0]
-        input_queue_next = self.mvs.execute("CN", [])[0]
-        value = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"input"}])
+        old_retval = self.mvs.execute("CN", [])
+        input_queue_first = self.mvs.execute("CN", [])
+        input_queue_next = self.mvs.execute("CN", [])
+        value = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -32,21 +32,21 @@ class TestInput(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], value)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "input"])[0], input_queue_next)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"]), value)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "input"]), input_queue_next)
 
     def test_input_none(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"input"}])[0]
-        old_retval = self.mvs.execute("CN", [])[0]
-        input_queue_first = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"input"}])
+        old_retval = self.mvs.execute("CN", [])
+        input_queue_first = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -59,9 +59,9 @@ class TestInput(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], old_retval)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "input"])[0], input_queue_first)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"]), old_retval)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "input"]), input_queue_first)

kernel/test/rules/test_rules_output.py

@@ -5,17 +5,17 @@ from utils import execute_until_finished, MvSWrapper
 class TestOutput(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
     def test_output_init(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"output"}])[0]
-        value = self.mvs.execute("CN", [])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"output"}])
+        value = self.mvs.execute("CN", [])
+        evalstack = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -28,25 +28,25 @@ class TestOutput(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], value)
-        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), value)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])
         self.assertNotEquals(new_evalstack, evalstack)
-        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "output")
+        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"]), evalstack)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])]), "output")
 
     def test_output_output(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["output"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"output"}])[0]
-        retval = self.mvs.execute("CN", [])[0]
-        output_queue = self.mvs.execute("CN", [])[0]
-        value = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["output"])
+        inst = self.mvs.execute("CNV", [{"value":"output"}])
+        retval = self.mvs.execute("CN", [])
+        output_queue = self.mvs.execute("CN", [])
+        value = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -59,12 +59,12 @@ class TestOutput(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], retval)
-        output_queue_next = self.mvs.execute("RD", [task_root, "last_output"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"]), retval)
+        output_queue_next = self.mvs.execute("RD", [task_root, "last_output"])
         self.assertNotEquals(output_queue_next, output_queue)
-        self.assertEquals(self.mvs.execute("RD", [output_queue, "next"])[0], output_queue_next)
-        self.assertEquals(self.mvs.execute("RD", [output_queue, "value"])[0], retval)
+        self.assertEquals(self.mvs.execute("RD", [output_queue, "next"]), output_queue_next)
+        self.assertEquals(self.mvs.execute("RD", [output_queue, "value"]), retval)

kernel/test/rules/test_rules_resolve.py

@@ -5,19 +5,19 @@ from utils import execute_until_finished, MvSWrapper
 class Testresolve(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
     def test_resolve_init_local(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        var_inst = self.mvs.execute("CN", [])[0]
-        symbols = self.mvs.execute("CN", [])[0]
-        returnvalue = self.mvs.execute("CN", [])[0]
-        entry = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"resolve"}])
+        var_inst = self.mvs.execute("CN", [])
+        symbols = self.mvs.execute("CN", [])
+        returnvalue = self.mvs.execute("CN", [])
+        entry = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -25,35 +25,35 @@ class Testresolve(unittest.TestCase):
         self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "var", var_inst])
         self.mvs.execute("CD", [task_frame, "symbols", symbols])
-        self.mvs.execute("CD", [task_frame, "returnvalue", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [task_frame, "evalstack", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "returnvalue", self.mvs.execute("CN", [])])
+        self.mvs.execute("CD", [task_frame, "evalstack", self.mvs.execute("CN", [])])
 
-        t1 = self.mvs.execute("CE", [symbols, entry])[0]
-        self.mvs.execute("CE", [t1, var_inst])[0]
+        t1 = self.mvs.execute("CE", [symbols, entry])
+        self.mvs.execute("CE", [t1, var_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], entry)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"]), entry)
 
     def test_resolve_init_global(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        _globals = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        _globals = self.mvs.execute("CN", [])
         self.mvs.execute("CD", [task_root, "globals", _globals])
-        global_task = self.mvs.execute("RD", [task_root, "globals"])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        var_inst = self.mvs.execute("CNV", ["var"])[0]
-        symbols = self.mvs.execute("CN", [])[0]
-        returnvalue = self.mvs.execute("CN", [])[0]
-        entry = self.mvs.execute("CN", [])[0]
+        global_task = self.mvs.execute("RD", [task_root, "globals"])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"resolve"}])
+        var_inst = self.mvs.execute("CNV", ["var"])
+        symbols = self.mvs.execute("CN", [])
+        returnvalue = self.mvs.execute("CN", [])
+        entry = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -61,34 +61,34 @@ class Testresolve(unittest.TestCase):
         self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "var", var_inst])
         self.mvs.execute("CD", [task_frame, "symbols", symbols])
-        self.mvs.execute("CD", [task_frame, "returnvalue", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [task_frame, "evalstack", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "returnvalue", self.mvs.execute("CN", [])])
+        self.mvs.execute("CD", [task_frame, "evalstack", self.mvs.execute("CN", [])])
 
-        t1 = self.mvs.execute("CE", [global_task, entry])[0]
-        self.mvs.execute("CE", [t1, var_inst])[0]
+        t1 = self.mvs.execute("CE", [global_task, entry])
+        self.mvs.execute("CE", [t1, var_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], entry)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"]), entry)
 
     def test_resolve_init_local_over_global(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        global_task = self.mvs.execute("RD", [task_root, "globals"])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
-        var_inst = self.mvs.execute("CNV", ["var"])[0]
-        symbols = self.mvs.execute("CN", [])[0]
-        returnvalue = self.mvs.execute("CN", [])[0]
-        local_entry = self.mvs.execute("CN", [])[0]
-        global_entry = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        global_task = self.mvs.execute("RD", [task_root, "globals"])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"resolve"}])
+        var_inst = self.mvs.execute("CNV", ["var"])
+        symbols = self.mvs.execute("CN", [])
+        returnvalue = self.mvs.execute("CN", [])
+        local_entry = self.mvs.execute("CN", [])
+        global_entry = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -96,20 +96,20 @@ class Testresolve(unittest.TestCase):
         self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "var", var_inst])
         self.mvs.execute("CD", [task_frame, "symbols", symbols])
-        self.mvs.execute("CD", [task_frame, "returnvalue", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [task_frame, "evalstack", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "returnvalue", self.mvs.execute("CN", [])])
+        self.mvs.execute("CD", [task_frame, "evalstack", self.mvs.execute("CN", [])])
 
-        t1 = self.mvs.execute("CE", [global_task, global_entry])[0]
-        self.mvs.execute("CE", [t1, var_inst])[0]
-        t2 = self.mvs.execute("CE", [symbols, local_entry])[0]
-        self.mvs.execute("CE", [t2, var_inst])[0]
+        t1 = self.mvs.execute("CE", [global_task, global_entry])
+        self.mvs.execute("CE", [t1, var_inst])
+        t2 = self.mvs.execute("CE", [symbols, local_entry])
+        self.mvs.execute("CE", [t2, var_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], local_entry)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"]), local_entry)

kernel/test/rules/test_rules_return.py

@@ -5,16 +5,16 @@ from utils import execute_until_finished, MvSWrapper
 class Testreturn(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
     def test_return_init(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"return"}])[0]
-        prev_stackframe = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"return"}])
+        prev_stackframe = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -26,17 +26,17 @@ class Testreturn(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], prev_stackframe)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), prev_stackframe)
 
     def test_return_init_value(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"return"}])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        value = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"return"}])
+        evalstack = self.mvs.execute("CN", [])
+        value = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -49,25 +49,25 @@ class Testreturn(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], value)
-        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), value)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])
         self.assertNotEquals(evalstack, new_evalstack)
-        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "eval")
+        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"]), evalstack)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])]), "eval")
 
     def test_return_eval(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["eval"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"return"}])[0]
-        prev_stackframe = self.mvs.execute("CN", [])[0]
-        returnvalue_top = self.mvs.execute("CN", [])[0]
-        returnvalue_bottom = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["eval"])
+        inst = self.mvs.execute("CNV", [{"value":"return"}])
+        prev_stackframe = self.mvs.execute("CN", [])
+        returnvalue_top = self.mvs.execute("CN", [])
+        returnvalue_bottom = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -81,6 +81,6 @@ class Testreturn(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], prev_stackframe)
-        self.assertEquals(self.mvs.execute("RD", [prev_stackframe, "returnvalue"])[0], returnvalue_top)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), prev_stackframe)
+        self.assertEquals(self.mvs.execute("RD", [prev_stackframe, "returnvalue"]), returnvalue_top)

kernel/test/rules/test_rules_while.py

@@ -5,17 +5,17 @@ from utils import execute_until_finished, MvSWrapper
 class Testwhile(unittest.TestCase):
     def setUp(self):
         self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
+        self.root = self.mvs.execute("RR", [])
         self.mvk = ModelverseKernel(self.root)
 
     def test_while_evaluate_condition(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["init"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        cond = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["init"])
+        inst = self.mvs.execute("CNV", [{"value":"while"}])
+        evalstack = self.mvs.execute("CN", [])
+        cond = self.mvs.execute("CN", [])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -28,25 +28,25 @@ class Testwhile(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], cond)
-        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), cond)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])
         self.assertNotEquals(evalstack, new_evalstack)
-        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "cond")
+        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"]), evalstack)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])]), "cond")
 
     def test_while_true(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["cond"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
-        evalstack = self.mvs.execute("CN", [])[0]
-        body = self.mvs.execute("CN", [])[0]
-        returnvalue = self.mvs.execute("CNV", [True])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["cond"])
+        inst = self.mvs.execute("CNV", [{"value":"while"}])
+        evalstack = self.mvs.execute("CN", [])
+        body = self.mvs.execute("CN", [])
+        returnvalue = self.mvs.execute("CNV", [True])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -60,23 +60,23 @@ class Testwhile(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], body)
-        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), body)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])
         self.assertNotEquals(evalstack, new_evalstack)
-        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
-        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"]), evalstack)
+        self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"]), inst)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])]), "init")
 
     def test_while_false(self):
         root = self.root
-        task_root = self.mvs.execute("CN", [])[0]
-        task_frame = self.mvs.execute("CN", [])[0]
-        phase = self.mvs.execute("CNV", ["cond"])[0]
-        inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
-        returnvalue = self.mvs.execute("CNV", [False])[0]
+        task_root = self.mvs.execute("CN", [])
+        task_frame = self.mvs.execute("CN", [])
+        phase = self.mvs.execute("CNV", ["cond"])
+        inst = self.mvs.execute("CNV", [{"value":"while"}])
+        returnvalue = self.mvs.execute("CNV", [False])
 
         self.mvs.execute("CD", [root, "task_1", task_root])
         self.mvs.execute("CD", [task_root, "frame", task_frame])
@@ -88,7 +88,7 @@ class Testwhile(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
-        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"]), task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"]), task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])]), "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"]), inst)

kernel/test/rules/utils.py

@@ -32,21 +32,21 @@ class MvSWrapper(object):
         retval = self.mapping[command](*params)
         retval = json.loads(json.dumps(retval))
 
-        return [retval[0]]
+        return retval
 
 def add_new_task(root, mvs, taskname):
-    hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
-    initial = mvs.execute("RD", [hierarchy, "__IP"])[0]
+    hierarchy = mvs.execute("RD", [root, "__hierarchy"])
+    initial = mvs.execute("RD", [hierarchy, "__IP"])
 
-    task_root = mvs.execute("CN", [])[0]
-    _globals = mvs.execute("CN", [])[0]
-    frame = mvs.execute("CN", [])[0]
-    evalstack = mvs.execute("CN", [])[0]
-    symbols = mvs.execute("CN", [])[0]
-    _input = mvs.execute("CN", [])[0]
-    _output = mvs.execute("CN", [])[0]
-    returnvalue = mvs.execute("CN", [])[0]
-    phase = mvs.execute("CNV", ["init"])[0]
+    task_root = mvs.execute("CN", [])
+    _globals = mvs.execute("CN", [])
+    frame = mvs.execute("CN", [])
+    evalstack = mvs.execute("CN", [])
+    symbols = mvs.execute("CN", [])
+    _input = mvs.execute("CN", [])
+    _output = mvs.execute("CN", [])
+    returnvalue = mvs.execute("CN", [])
+    phase = mvs.execute("CNV", ["init"])
 
     mvs.execute("CD", [root, taskname, task_root])
     mvs.execute("CD", [task_root, "frame", frame])
@@ -72,49 +72,49 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
             break
         response = []
         for command, param in mvs_commands:
-            response.append(mvs.execute(command, param)[0])
+            response.append(mvs.execute(command, param))
 
 def get_inst(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    inst = mvs.execute("RD", [task_frame, "IP"])[0]
-    return mvs.execute("RV", [inst])[0]["value"]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    inst = mvs.execute("RD", [task_frame, "IP"])
+    return mvs.execute("RV", [inst])["value"]
 
 def get_phase(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    phase = mvs.execute("RD", [task_frame, "phase"])[0]
-    return mvs.execute("RV", [phase])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    phase = mvs.execute("RD", [task_frame, "phase"])
+    return mvs.execute("RV", [phase])
 
 def get_returnvalue(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])[0]
-    return mvs.execute("RV", [returnvalue])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])
+    return mvs.execute("RV", [returnvalue])
 
 def get_inst_ref(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    return mvs.execute("RD", [task_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    return mvs.execute("RD", [task_frame, "IP"])
 
 def get_returnvalue_ref(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    return mvs.execute("RD", [task_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    return mvs.execute("RD", [task_frame, "returnvalue"])
 
 def get_phase_ref(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    phase = mvs.execute("RD", [task_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    phase = mvs.execute("RD", [task_frame, "phase"])
     return phase
 
 def read_primitive_interfaces(root, mvs):
-    hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
-    primitives = mvs.execute("RD", [hierarchy, "primitives"])[0]
-    keys = mvs.execute("RDK", [primitives])[0]
+    hierarchy = mvs.execute("RD", [root, "__hierarchy"])
+    primitives = mvs.execute("RD", [hierarchy, "primitives"])
+    keys = mvs.execute("RDK", [primitives])
     d = {}
     for k in keys:
-        value = mvs.execute("RDN", [primitives, k])[0]
-        name = mvs.execute("RV", [k])[0]
+        value = mvs.execute("RDN", [primitives, k])
+        name = mvs.execute("RV", [k])
         d[name] = value
     return d

kernel/test/utils.py

@@ -32,21 +32,21 @@ class MvSWrapper(object):
         retval = self.mapping[command](*params)
         retval = json.loads(json.dumps(retval))
 
-        return [retval[0]]
+        return retval
 
 def add_new_task(root, mvs, taskname):
-    hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
-    initial = mvs.execute("RD", [hierarchy, "__IP"])[0]
+    hierarchy = mvs.execute("RD", [root, "__hierarchy"])
+    initial = mvs.execute("RD", [hierarchy, "__IP"])
 
-    task_root = mvs.execute("CN", [])[0]
-    _globals = mvs.execute("CN", [])[0]
-    frame = mvs.execute("CN", [])[0]
-    evalstack = mvs.execute("CN", [])[0]
-    symbols = mvs.execute("CN", [])[0]
-    _input = mvs.execute("CN", [])[0]
-    _output = mvs.execute("CN", [])[0]
-    returnvalue = mvs.execute("CN", [])[0]
-    phase = mvs.execute("CNV", ["init"])[0]
+    task_root = mvs.execute("CN", [])
+    _globals = mvs.execute("CN", [])
+    frame = mvs.execute("CN", [])
+    evalstack = mvs.execute("CN", [])
+    symbols = mvs.execute("CN", [])
+    _input = mvs.execute("CN", [])
+    _output = mvs.execute("CN", [])
+    returnvalue = mvs.execute("CN", [])
+    phase = mvs.execute("CNV", ["init"])
 
     mvs.execute("CD", [root, taskname, task_root])
     mvs.execute("CD", [task_root, "frame", frame])
@@ -72,49 +72,49 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
             break
         response = []
         for command, param in mvs_commands:
-            response.append(mvs.execute(command, param)[0])
+            response.append(mvs.execute(command, param))
 
 def get_inst(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    inst = mvs.execute("RD", [task_frame, "IP"])[0]
-    return mvs.execute("RV", [inst])[0]["value"]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    inst = mvs.execute("RD", [task_frame, "IP"])
+    return mvs.execute("RV", [inst])["value"]
 
 def get_phase(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    phase = mvs.execute("RD", [task_frame, "phase"])[0]
-    return mvs.execute("RV", [phase])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    phase = mvs.execute("RD", [task_frame, "phase"])
+    return mvs.execute("RV", [phase])
 
 def get_returnvalue(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])[0]
-    return mvs.execute("RV", [returnvalue])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])
+    return mvs.execute("RV", [returnvalue])
 
 def get_inst_ref(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    return mvs.execute("RD", [task_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    return mvs.execute("RD", [task_frame, "IP"])
 
 def get_returnvalue_ref(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    return mvs.execute("RD", [task_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    return mvs.execute("RD", [task_frame, "returnvalue"])
 
 def get_phase_ref(root, mvs):
-    task_root = mvs.execute("RD", [root, "task_1"])[0]
-    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
-    phase = mvs.execute("RD", [task_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])
+    task_frame = mvs.execute("RD", [task_root, "frame"])
+    phase = mvs.execute("RD", [task_frame, "phase"])
     return phase
 
 def read_primitive_interfaces(root, mvs):
-    hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
-    primitives = mvs.execute("RD", [hierarchy, "primitives"])[0]
-    keys = mvs.execute("RDK", [primitives])[0]
+    hierarchy = mvs.execute("RD", [root, "__hierarchy"])
+    primitives = mvs.execute("RD", [hierarchy, "primitives"])
+    keys = mvs.execute("RDK", [primitives])
     d = {}
     for k in keys:
-        value = mvs.execute("RDN", [primitives, k])[0]
-        name = mvs.execute("RV", [k])[0]
+        value = mvs.execute("RDN", [primitives, k])
+        name = mvs.execute("RV", [k])
         d[name] = value
     return d

state/modelverse_state/main.py

@@ -38,7 +38,7 @@ class ModelverseState(object):
         if bootfile is not None:
             self.root = self.parse(bootfile)
         else:
-            self.root, _ = self.create_node()
+            self.root = self.create_node()
 
     def dump_modelverse(self):
         with open("/tmp/modelverse.out", "w") as f:
@@ -76,9 +76,9 @@ class ModelverseState(object):
                 except:
                     if symb[0] == "?":
                         derefs = symb[1:].split("/")
-                        v, _ = self.read_dict(symbols["root"], "__hierarchy")
+                        v = self.read_dict(symbols["root"], "__hierarchy")
                         for deref in derefs:
-                            v, _ = self.read_dict(v, deref)
+                            v = self.read_dict(v, deref)
                         return v
                     else:
                         return symbols[symb]

state/test/test_create_dict.py

@@ -1,45 +1,40 @@
 import unittest
 from modelverse_state.main import ModelverseState
 
-from modelverse_state import status
-
 class TestCreateDict(unittest.TestCase):
     def setUp(self):
         self.mvs = ModelverseState()
 
     def test_create_dict_simple(self):
-        id1, r1 = self.mvs.create_node()
-        id2, r2 = self.mvs.create_node()
-        self.assertEquals(r1, status.SUCCESS)
-        self.assertEquals(r2, status.SUCCESS)
+        id1 = self.mvs.create_node()
+        id2 = self.mvs.create_node()
+        assert id1 != None
+        assert id2 != None
 
-        n, r = self.mvs.create_dict(id1, "abc", id2)
-        self.assertEquals(r, status.SUCCESS)
+        n = self.mvs.create_dict(id1, "abc", id2)
+        assert n == None
 
-        v, r = self.mvs.read_dict(id1, "abc")
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, id2)
+        v = self.mvs.read_dict(id1, "abc")
+        assert v == id2
 
     def test_create_dict_no_source(self):
         id1 = 100000
-        id2, r2 = self.mvs.create_node()
-        self.assertEquals(r2, status.SUCCESS)
+        id2 = self.mvs.create_node()
+        assert id2 != None
 
-        n, r = self.mvs.create_dict(id1, "abc", id2)
-        self.assertEquals(r, status.FAIL_CDICT_SOURCE)
+        n = self.mvs.create_dict(id1, "abc", id2)
+        assert n == None
 
-        v, r = self.mvs.read_dict(id1, "abc")
-        self.assertEquals(r, status.FAIL_RDICT_UNKNOWN)
-        self.assertEquals(v, None)
+        v = self.mvs.read_dict(id1, "abc")
+        assert v == None
 
     def test_create_dict_no_target(self):
         id2 = 100000
-        id1, r2 = self.mvs.create_node()
-        self.assertEquals(r2, status.SUCCESS)
+        id1 = self.mvs.create_node()
+        assert id1 != None
 
-        n, r = self.mvs.create_dict(id1, "abc", id2)
-        self.assertEquals(r, status.FAIL_CDICT_TARGET)
+        n = self.mvs.create_dict(id1, "abc", id2)
+        assert n == None
 
-        v, r = self.mvs.read_dict(id1, "abc")
-        self.assertEquals(r, status.FAIL_RDICT_NOT_FOUND)
-        self.assertEquals(v, None)
+        v = self.mvs.read_dict(id1, "abc")
+        assert v == None

state/test/test_create_edge.py

@@ -1,157 +1,153 @@
 import unittest
 from modelverse_state.main import ModelverseState
 
-from modelverse_state import status
-
 class TestCreateEdge(unittest.TestCase):
     def setUp(self):
         self.mvs = ModelverseState()
 
     def test_create_edge_invalid_source(self):
         a = -1
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        b = self.mvs.create_node()
+        assert b != None
 
-        edge, r = self.mvs.create_edge(a, b)
-        self.assertEquals(edge, None)
-        self.assertEquals(r, status.FAIL_CE_SOURCE)
+        edge = self.mvs.create_edge(a, b)
+        assert edge == None
 
     def test_create_edge_invalid_target(self):
         b = -1
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
 
-        edge, r = self.mvs.create_edge(a, b)
-        self.assertEquals(edge, None)
-        self.assertEquals(r, status.FAIL_CE_TARGET)
+        edge = self.mvs.create_edge(a, b)
+        assert edge == None
 
     def test_create_edge_invalid_both(self):
         a = -1
         b = -1
-        edge, r = self.mvs.create_edge(a, b)
-        self.assertEquals(edge, None)
-        self.assertEquals(r, status.FAIL_CE_SOURCE)
+        edge = self.mvs.create_edge(a, b)
+        assert edge == None
 
     def test_create_edge_node_to_node(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
+        b = self.mvs.create_node()
+        assert b != None
 
-        edge, r = self.mvs.create_edge(a, b)
-        self.assertGreater(edge,a)
-        self.assertGreater(edge,b)
-        self.assertEquals(r, status.SUCCESS)
+        edge = self.mvs.create_edge(a, b)
+        assert edge != None
+        assert edge > a
+        assert edge > b
 
     def test_create_edge_multiple(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
+        b = self.mvs.create_node()
+        assert b != None
 
-        edge1, r = self.mvs.create_edge(a, b)
-        self.assertGreater(edge1,a)
-        self.assertGreater(edge1,b)
-        self.assertEquals(r, status.SUCCESS)
+        edge1 = self.mvs.create_edge(a, b)
+        assert edge1 != None
+        assert edge1 > a
+        assert edge1 > b
 
-        edge2, r = self.mvs.create_edge(a, b)
-        self.assertGreater(edge2,a)
-        self.assertGreater(edge2,b)
-        self.assertEquals(r, status.SUCCESS)
+        edge2 = self.mvs.create_edge(a, b)
+        assert edge2 != None
+        assert edge2 > a
+        assert edge2 > b
 
-        self.assertNotEquals(edge1, edge2)
+        assert edge1 != edge2
 
     def test_create_edge_many(self):
         v = set()
         for i in range(1000):
-            a, r = self.mvs.create_node()
-            self.assertEquals(r, status.SUCCESS)
-            b, r = self.mvs.create_node()
-            self.assertEquals(r, status.SUCCESS)
+            a = self.mvs.create_node()
+            assert a != None
+            b = self.mvs.create_node()
+            assert b != None
 
-            edge, r = self.mvs.create_edge(a, b)
+            edge = self.mvs.create_edge(a, b)
+            assert edge != None
+            assert edge > a
+            assert edge > b
 
-            self.assertGreater(edge,a)
-            self.assertGreater(edge,b)
-            self.assertEquals(r, status.SUCCESS)
             v.add(edge)
-        self.assertEquals(len(v), 1000)
+        assert len(v) == 1000
 
     def test_create_edge_edge_to_node(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
+        b = self.mvs.create_node()
+        assert b != None
 
-        edge1, r = self.mvs.create_edge(a, b)
-        self.assertGreater(edge1,a)
-        self.assertGreater(edge1,b)
-        self.assertEquals(r, status.SUCCESS)
+        edge1 = self.mvs.create_edge(a, b)
+        assert edge1 != None
+        assert edge1 > a
+        assert edge1 > b
 
-        edge2, r = self.mvs.create_edge(edge1, b)
-        self.assertGreater(edge2,edge1)
-        self.assertGreater(edge2,b)
-        self.assertEquals(r, status.SUCCESS)
+        edge2 = self.mvs.create_edge(edge1, b)
+        assert edge2 != None
+        assert edge2 > edge1
+        assert edge2 > b
 
-        self.assertNotEquals(edge1, edge2)
+        assert edge1 != edge2
 
     def test_create_edge_node_to_edge(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
+        b = self.mvs.create_node()
+        assert b != None
 
-        edge1, r = self.mvs.create_edge(a, b)
-        self.assertGreater(edge1,a)
-        self.assertGreater(edge1,b)
-        self.assertEquals(r, status.SUCCESS)
+        edge1 = self.mvs.create_edge(a, b)
+        assert edge1 != None
+        assert edge1 > a
+        assert edge1 > b
 
-        edge2, r = self.mvs.create_edge(a, edge1)
-        self.assertGreater(edge2,a)
-        self.assertGreater(edge2,edge1)
-        self.assertEquals(r, status.SUCCESS)
+        edge2 = self.mvs.create_edge(a, edge1)
+        assert edge2 != None
+        assert edge2 > a
+        assert edge2 > edge1
 
-        self.assertNotEquals(edge1, edge2)
+        assert edge1 != edge2
 
     def test_create_edge_edge_to_edge(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
+        b = self.mvs.create_node()
+        assert b != None
 
-        edge1, r = self.mvs.create_edge(a, b)
-        self.assertGreater(edge1,a)
-        self.assertGreater(edge1,b)
-        self.assertEquals(r, status.SUCCESS)
+        edge1 = self.mvs.create_edge(a, b)
+        assert edge1 != None
+        assert edge1 > a
+        assert edge1 > b
 
-        edge2, r = self.mvs.create_edge(a, b)
-        self.assertGreater(edge2,a)
-        self.assertGreater(edge2,b)
-        self.assertEquals(r, status.SUCCESS)
+        edge2 = self.mvs.create_edge(a, b)
+        assert edge2 != None
+        assert edge2 > a
+        assert edge2 > b
 
-        self.assertNotEquals(edge1, edge2)
+        assert edge1 != edge2
 
-        edge3, r = self.mvs.create_edge(edge1, edge2)
-        self.assertGreater(edge3,edge1)
-        self.assertGreater(edge3,edge2)
-        self.assertEquals(r, status.SUCCESS)
+        edge3 = self.mvs.create_edge(edge1, edge2)
+        assert edge3 != None
+        assert edge3 > edge1
+        assert edge3 > edge2
 
     def test_create_edge_loop_node(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
 
-        edge, r = self.mvs.create_edge(a, a)
-        self.assertGreater(edge,a)
-        self.assertEquals(r, status.SUCCESS)
+        edge = self.mvs.create_edge(a, a)
+        assert edge != None
+        assert edge > a
 
     def test_create_edge_loop_edge(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
 
-        edge1, r = self.mvs.create_edge(a, a)
-        self.assertGreater(edge1,a)
-        self.assertEquals(r, status.SUCCESS)
+        edge1 = self.mvs.create_edge(a, a)
+        assert edge1 != None
+        assert edge1 > a
 
-        edge2, r = self.mvs.create_edge(edge1, edge1)
-        self.assertGreater(edge2,a)
-        self.assertEquals(r, status.SUCCESS)
+        edge2 = self.mvs.create_edge(edge1, edge1)
+        assert edge2 != None
+        assert edge2 > a
+        assert edge2 > edge1

state/test/test_create_node.py

@@ -1,24 +1,23 @@
 import unittest
 from modelverse_state.main import ModelverseState
 
-from modelverse_state import status
-
 class TestCreateNode(unittest.TestCase):
     def setUp(self):
         self.mvs = ModelverseState()
 
     def test_create_node_different_id_simple(self):
-        id1, r1 = self.mvs.create_node()
-        id2, r2 = self.mvs.create_node()
+        id1 = self.mvs.create_node()
+        assert id1 != None
+        id2 = self.mvs.create_node()
+        assert id2 != None
         
-        self.assertEquals(r1, status.SUCCESS)
-        self.assertEquals(r2, status.SUCCESS)
-        self.assertNotEquals(id1, id2)
+        assert id1 != id2
 
     def test_create_node_different_id_long(self):
         results = set()
         for i in range(1000):
-            v, r = self.mvs.create_node()
-            self.assertEquals(r, status.SUCCESS)
+            v = self.mvs.create_node()
+            assert v != None
             results.add(v)
-        self.assertEquals(len(results), 1000)
+
+        assert len(results) == 1000

state/test/test_create_nodevalue.py

@@ -1,203 +1,201 @@
 import unittest
 from modelverse_state.main import ModelverseState
 
-from modelverse_state import status
-
 class TestCreateNodeValue(unittest.TestCase):
     def setUp(self):
         self.mvs = ModelverseState()
 
     def test_create_nodevalue_different_id_simple(self):
-        id1, r1 = self.mvs.create_nodevalue(1)
-        id2, r2 = self.mvs.create_nodevalue(1)
-        
-        self.assertEquals(r1, status.SUCCESS)
-        self.assertEquals(r2, status.SUCCESS)
-        self.assertNotEquals(id1, id2)
+        id1 = self.mvs.create_nodevalue(1)
+        id2 = self.mvs.create_nodevalue(1)
 
+        assert id1 != None
+        assert id2 != None
+        assert id1 != id2
+        
     def test_create_nodevalue_read(self):
-        id1, r1 = self.mvs.create_nodevalue(1)
-        self.assertEquals(r1, status.SUCCESS)
-        val, r2 = self.mvs.read_value(id1)
-        self.assertEquals(r2, status.SUCCESS)
-        self.assertEquals(val, 1)
+        id1 = self.mvs.create_nodevalue(1)
+        assert id1 != None
+        val = self.mvs.read_value(id1)
+        assert val == 1
 
     def test_create_nodevalue_integer_ib_zero(self):
         # Nicely within range
         v = set()
         size = 0
         for i in range(-10, 10):
-            id1, r = self.mvs.create_nodevalue(i)
-            self.assertEquals(r, status.SUCCESS)
+            id1 = self.mvs.create_nodevalue(i)
+            assert id1 != None
             size += 1
             v.add(id1)
-        self.assertEquals(len(v), size)
+        assert len(v) == size
 
     def test_create_nodevalue_boolean(self):
-        id1, r1 = self.mvs.create_nodevalue(True)
-        id2, r2 = self.mvs.create_nodevalue(False)
-        
-        self.assertEquals(r1, status.SUCCESS)
-        self.assertEquals(r2, status.SUCCESS)
-        self.assertNotEquals(id1, id2)
+        id1 = self.mvs.create_nodevalue(True)
+        id2 = self.mvs.create_nodevalue(False)
 
+        assert id1 != None
+        assert id2 != None
+        assert id1 != id2
+        
     def test_create_nodevalue_boolean_same(self):
-        id1, r1 = self.mvs.create_nodevalue(True)
-        id2, r2 = self.mvs.create_nodevalue(True)
+        id1 = self.mvs.create_nodevalue(True)
+        id2 = self.mvs.create_nodevalue(True)
+        
+        assert id1 != None
+        assert id2 != None
+        assert id1 != id2
         
-        self.assertEquals(r1, status.SUCCESS)
-        self.assertEquals(r2, status.SUCCESS)
-        self.assertNotEquals(id1, id2)
-
     def test_create_nodevalue_float_keeps_type(self):
-        id1, r = self.mvs.create_nodevalue(0.0)
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(type(v), float)
-        self.assertEquals(v, 0.0)
+        id1 = self.mvs.create_nodevalue(0.0)
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert type(v) == float
+        assert v == 0.0
 
     def test_create_nodevalue_string_empty(self):
-        id1, r = self.mvs.create_nodevalue("")
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(type(v), str)
-        self.assertEquals(v, "")
+        id1 = self.mvs.create_nodevalue("")
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert type(v) == str
+        assert v == ""
 
     def test_create_nodevalue_string_normal(self):
-        id1, r = self.mvs.create_nodevalue("ABC")
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(type(v), str)
-        self.assertEquals(v, "ABC")
+        id1 = self.mvs.create_nodevalue("ABC")
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert type(v) == str
+        assert v == "ABC"
 
     def test_create_nodevalue_string_not_parsed(self):
-        id1, r = self.mvs.create_nodevalue("1")
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(type(v), str)
-        self.assertEquals(v, "1")
-
-        id1, r = self.mvs.create_nodevalue("1.0")
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(type(v), str)
-        self.assertEquals(v, "1.0")
-
-        id1, r = self.mvs.create_nodevalue("-1.0")
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(type(v), str)
-        self.assertEquals(v, "-1.0")
-
-        id1, r = self.mvs.create_nodevalue("True")
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(type(v), str)
-        self.assertEquals(v, "True")
+        id1 = self.mvs.create_nodevalue("1")
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert type(v) == str
+        assert v == "1"
+
+        id1 = self.mvs.create_nodevalue("1.0")
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert type(v) == str
+        assert v == "1.0"
+
+        id1 = self.mvs.create_nodevalue("-1.0")
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert type(v) == str
+        assert v == "-1.0"
+
+        id1 = self.mvs.create_nodevalue("True")
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert type(v) == str
+        assert v == "True"
 
     def test_create_nodevalue_junk(self):
         class Unknown(object):
             pass
 
-        id1, r = self.mvs.create_nodevalue(Unknown())
-        self.assertEquals(r, status.FAIL_CNV_OOB)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.FAIL_RV_UNKNOWN)
-        self.assertEquals(v, None)
+        id1 = self.mvs.create_nodevalue(Unknown())
+        assert id1 == None
+
+        v = self.mvs.read_value(id1)
+        assert v == None
 
     def test_create_nodevalue_action_if(self):
-        id1, r = self.mvs.create_nodevalue({"value": "if"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "if"})
+        id1 = self.mvs.create_nodevalue({"value": "if"})
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert v == {"value": "if"}
 
     def test_create_nodevalue_action_while(self):
-        id1, r = self.mvs.create_nodevalue({"value": "while"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "while"})
+        id1 = self.mvs.create_nodevalue({"value": "while"})
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert v == {"value": "while"}
 
     def test_create_nodevalue_action_assign(self):
-        id1, r = self.mvs.create_nodevalue({"value": "assign"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "assign"})
+        id1 = self.mvs.create_nodevalue({"value": "assign"})
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert v == {"value": "assign"}
 
     def test_create_nodevalue_action_call(self):
-        id1, r = self.mvs.create_nodevalue({"value": "call"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "call"})
+        id1 = self.mvs.create_nodevalue({"value": "call"})
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert v == {"value": "call"}
 
     def test_create_nodevalue_action_break(self):
-        id1, r = self.mvs.create_nodevalue({"value": "break"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "break"})
+        id1 = self.mvs.create_nodevalue({"value": "break"})
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert v == {"value": "break"}
 
     def test_create_nodevalue_action_continue(self):
-        id1, r = self.mvs.create_nodevalue({"value": "continue"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "continue"})
+        id1 = self.mvs.create_nodevalue({"value": "continue"})
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert v == {"value": "continue"}
 
     def test_create_nodevalue_action_return(self):
-        id1, r = self.mvs.create_nodevalue({"value": "return"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "return"})
+        id1 = self.mvs.create_nodevalue({"value": "return"})
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert v == {"value": "return"}
 
     def test_create_nodevalue_action_resolve(self):
-        id1, r = self.mvs.create_nodevalue({"value": "resolve"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "resolve"})
+        id1 = self.mvs.create_nodevalue({"value": "resolve"})
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert v == {"value": "resolve"}
 
     def test_create_nodevalue_action_access(self):
-        id1, r = self.mvs.create_nodevalue({"value": "access"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "access"})
+        id1 = self.mvs.create_nodevalue({"value": "access"})
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert v == {"value": "access"}
 
     def test_create_nodevalue_action_unknown(self):
-        id1, r = self.mvs.create_nodevalue({"value": "unknown"})
-        self.assertEquals(r, status.FAIL_CNV_OOB)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.FAIL_RV_UNKNOWN)
+        id1 = self.mvs.create_nodevalue({"value": "unknown"})
+        assert id1 == None
+
+        v = self.mvs.read_value(id1)
+        assert v == None
 
     def test_create_nodevalue_action_input(self):
-        id1, r = self.mvs.create_nodevalue({"value": "input"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "input"})
+        id1 = self.mvs.create_nodevalue({"value": "input"})
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert v == {"value": "input"}
 
     def test_create_nodevalue_action_output(self):
-        id1, r = self.mvs.create_nodevalue({"value": "output"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "output"})
+        id1 = self.mvs.create_nodevalue({"value": "output"})
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert v == {"value": "output"}
 
     def test_create_nodevalue_action_declare(self):
-        id1, r = self.mvs.create_nodevalue({"value": "declare"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "declare"})
+        id1 = self.mvs.create_nodevalue({"value": "declare"})
+        assert id1 != None
+
+        v = self.mvs.read_value(id1)
+        assert v == {"value": "declare"}

state/test/test_delete_edge.py

@@ -1,445 +1,387 @@
 import unittest
 from modelverse_state.main import ModelverseState
 
-from modelverse_state import status
-
 class TestDeleteEdge(unittest.TestCase):
     def setUp(self):
         self.mvs = ModelverseState()
 
     def test_delete_edge_no_exists(self):
-        n, r = self.mvs.delete_edge(1)
-        self.assertEquals(r, status.FAIL_DE_UNKNOWN)
+        n = self.mvs.delete_edge(1)
+        assert n == None
 
     def test_delete_edge_node(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
 
-        n, r = self.mvs.delete_edge(a)
-        self.assertEquals(r, status.FAIL_DE_UNKNOWN)
+        n = self.mvs.delete_edge(a)
+        assert n == None
 
     def test_delete_edge_nodevalue(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_nodevalue(1)
+        assert a != None
 
-        n, r = self.mvs.delete_edge(a)
-        self.assertEquals(r, status.FAIL_DE_UNKNOWN)
+        n = self.mvs.delete_edge(a)
+        assert n == None
 
     def test_delete_edge_normal(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        n, r = self.mvs.delete_edge(c)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(a)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(a)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
+        a = self.mvs.create_nodevalue(1)
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+
+        n = self.mvs.delete_edge(c)
+        assert n == None
+
+        l = self.mvs.read_outgoing(a)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(a)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_outgoing(b)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(b)
+        assert l != None
+        assert set(l) == set([])
 
     def test_delete_edge_remove_recursive(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(c, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        n, r = self.mvs.delete_edge(c)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_value(a)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(l, 1)
-
-        l, r = self.mvs.read_outgoing(a)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(a)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-
-        v, r = self.mvs.read_edge(c)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-
-        v, r = self.mvs.read_edge(d)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
+        a = self.mvs.create_nodevalue(1)
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        d = self.mvs.create_edge(c, b)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+
+        n = self.mvs.delete_edge(c)
+        assert n == None
+
+        l = self.mvs.read_value(a)
+        assert l == 1
+
+        l = self.mvs.read_outgoing(a)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(a)
+        assert l != None
+        assert set(l) == set([])
+
+        s, t = self.mvs.read_edge(c)
+        assert s == None
+        assert t == None
+
+        s, t = self.mvs.read_edge(d)
+        assert s == None
+        assert t == None
+
+        l = self.mvs.read_outgoing(b)
+        assert l != None
+        assert set(l) == set([])
 
     def test_delete_edge_remove_edge_recursive_deep(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-        f, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        g, r = self.mvs.create_edge(f, e)
-        self.assertEquals(r, status.SUCCESS)
-        h, r = self.mvs.create_edge(b, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        n, r = self.mvs.delete_edge(d)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(a)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(a)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([h]))
-
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_outgoing(c)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(c)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([h]))
-
-        v, r = self.mvs.read_edge(d)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-
-        v, r = self.mvs.read_edge(e)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-
-        v, r = self.mvs.read_edge(g)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-
-        l, r = self.mvs.read_outgoing(f)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(f)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        v, r = self.mvs.read_edge(h)
-        s, t = v
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(s, b)
-        self.assertEquals(t, c)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_node()
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(d, c)
+        f = self.mvs.create_node()
+        g = self.mvs.create_edge(f, e)
+        h = self.mvs.create_edge(b, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+        assert f != None
+        assert g != None
+        assert h != None
+
+        n = self.mvs.delete_edge(d)
+        assert n == None
+
+        l = self.mvs.read_outgoing(a)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(a)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_outgoing(b)
+        assert l != None
+        assert set(l) == set([h])
+
+        l = self.mvs.read_incoming(b)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_outgoing(c)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(c)
+        assert l != None
+        assert set(l) == set([h])
+
+        s, t = self.mvs.read_edge(d)
+        assert s == None
+        assert t == None
+
+        s, t = self.mvs.read_edge(e)
+        assert s == None
+        assert t == None
+
+        s, t = self.mvs.read_edge(g)
+        assert s == None
+        assert t == None
+
+        l = self.mvs.read_outgoing(f)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(f)
+        assert l != None
+        assert set(l) == set([])
+
+        s, t = self.mvs.read_edge(h)
+        assert s == b
+        assert t == c
 
     def test_delete_edge_remove_edge_recursive_steps(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-        f, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        g, r = self.mvs.create_edge(f, e)
-        self.assertEquals(r, status.SUCCESS)
-        h, r = self.mvs.create_edge(b, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        n, r = self.mvs.delete_edge(g)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(a)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([d]))
-
-        l, r = self.mvs.read_incoming(a)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([h]))
-
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([d]))
-
-        l, r = self.mvs.read_outgoing(c)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(c)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([h, e]))
-
-        v, r = self.mvs.read_edge(d)
-        s, t = v
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(s, a)
-        self.assertEquals(t, b)
-
-        l, r = self.mvs.read_outgoing(d)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([e]))
-
-        l, r = self.mvs.read_incoming(d)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        v, r = self.mvs.read_edge(e)
-        s, t = v
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(s, d)
-        self.assertEquals(t, c)
-
-        l, r = self.mvs.read_outgoing(e)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(e)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        v, r = self.mvs.read_edge(g)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-
-        l, r = self.mvs.read_outgoing(g)
-        self.assertEquals(r, status.FAIL_RO_UNKNOWN)
-        self.assertEquals(l, None)
-
-        l, r = self.mvs.read_incoming(g)
-        self.assertEquals(r, status.FAIL_RI_UNKNOWN)
-        self.assertEquals(l, None)
-
-        l, r = self.mvs.read_outgoing(f)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(f)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        v, r = self.mvs.read_edge(h)
-        s, t = v
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(s, b)
-        self.assertEquals(t, c)
-
-        n, r = self.mvs.delete_edge(e)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(a)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([d]))
-
-        l, r = self.mvs.read_incoming(a)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([h]))
-
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([d]))
-
-        l, r = self.mvs.read_outgoing(c)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(c)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([h]))
-
-        v, r = self.mvs.read_edge(d)
-        s, t = v
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(s, a)
-        self.assertEquals(t, b)
-
-        l, r = self.mvs.read_outgoing(d)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(d)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        v, r = self.mvs.read_edge(e)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-
-        l, r = self.mvs.read_outgoing(e)
-        self.assertEquals(r, status.FAIL_RO_UNKNOWN)
-        self.assertEquals(l, None)
-
-        l, r = self.mvs.read_incoming(e)
-        self.assertEquals(r, status.FAIL_RI_UNKNOWN)
-        self.assertEquals(l, None)
-
-        v, r = self.mvs.read_edge(g)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-
-        l, r = self.mvs.read_outgoing(g)
-        self.assertEquals(r, status.FAIL_RO_UNKNOWN)
-        self.assertEquals(l, None)
-
-        l, r = self.mvs.read_incoming(g)
-        self.assertEquals(r, status.FAIL_RI_UNKNOWN)
-        self.assertEquals(l, None)
-
-        l, r = self.mvs.read_outgoing(f)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(f)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        v, r = self.mvs.read_edge(h)
-        s, t = v
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(s, b)
-        self.assertEquals(t, c)
-
-        n, r = self.mvs.delete_edge(d)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(a)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(a)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([h]))
-
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_outgoing(c)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(c)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([h]))
-
-        v, r = self.mvs.read_edge(d)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-
-        l, r = self.mvs.read_outgoing(d)
-        self.assertEquals(r, status.FAIL_RO_UNKNOWN)
-        self.assertEquals(l, None)
-
-        l, r = self.mvs.read_incoming(d)
-        self.assertEquals(r, status.FAIL_RI_UNKNOWN)
-        self.assertEquals(l, None)
-
-        v, r = self.mvs.read_edge(e)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-
-        l, r = self.mvs.read_outgoing(e)
-        self.assertEquals(r, status.FAIL_RO_UNKNOWN)
-        self.assertEquals(l, None)
-
-        l, r = self.mvs.read_incoming(e)
-        self.assertEquals(r, status.FAIL_RI_UNKNOWN)
-        self.assertEquals(l, None)
-
-        v, r = self.mvs.read_edge(g)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-
-        l, r = self.mvs.read_outgoing(g)
-        self.assertEquals(r, status.FAIL_RO_UNKNOWN)
-        self.assertEquals(l, None)
-
-        l, r = self.mvs.read_incoming(g)
-        self.assertEquals(r, status.FAIL_RI_UNKNOWN)
-        self.assertEquals(l, None)
-
-        l, r = self.mvs.read_outgoing(f)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(f)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        v, r = self.mvs.read_edge(h)
-        s, t = v
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(s, b)
-        self.assertEquals(t, c)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_node()
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(d, c)
+        f = self.mvs.create_node()
+        g = self.mvs.create_edge(f, e)
+        h = self.mvs.create_edge(b, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+        assert f != None
+        assert g != None
+        assert h != None
+
+        n = self.mvs.delete_edge(g)
+        assert n == None
+
+        l = self.mvs.read_outgoing(a)
+        assert l != None
+        assert set(l) == set([d])
+
+        l = self.mvs.read_incoming(a)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_outgoing(b)
+        assert l != None
+        assert set(l) == set([h])
+
+        l = self.mvs.read_incoming(b)
+        assert l != None
+        assert set(l) == set([d])
+
+        l = self.mvs.read_outgoing(c)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(c)
+        assert l != None
+        assert set(l) == set([h, e])
+
+        s, t = self.mvs.read_edge(d)
+        assert s == a
+        assert t == b
+
+        l = self.mvs.read_outgoing(d)
+        assert l != None
+        assert set(l) == set([e])
+
+        l = self.mvs.read_incoming(d)
+        assert l != None
+        assert set(l) == set([])
+
+        s, t = self.mvs.read_edge(e)
+        assert s == d
+        assert t == c
+
+        l = self.mvs.read_outgoing(e)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(e)
+        assert l != None
+        assert set(l) == set([])
+
+        s, t = self.mvs.read_edge(g)
+        assert s == None
+        assert t == None
+
+        l = self.mvs.read_outgoing(g)
+        assert l == None
+
+        l = self.mvs.read_incoming(g)
+        assert l == None
+
+        l = self.mvs.read_outgoing(f)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(f)
+        assert l != None
+        assert set(l) == set([])
+
+        s, t = self.mvs.read_edge(h)
+        assert s == b
+        assert t == c
+
+        n = self.mvs.delete_edge(e)
+        assert n == None
+
+        l = self.mvs.read_outgoing(a)
+        assert l != None
+        assert set(l) == set([d])
+
+        l = self.mvs.read_incoming(a)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_outgoing(b)
+        assert l != None
+        assert set(l) == set([h])
+
+        l = self.mvs.read_incoming(b)
+        assert l != None
+        assert set(l) == set([d])
+
+        l = self.mvs.read_outgoing(c)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(c)
+        assert l != None
+        assert set(l) == set([h])
+
+        s, t = self.mvs.read_edge(d)
+        assert s == a
+        assert t == b
+
+        l = self.mvs.read_outgoing(d)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(d)
+        assert l != None
+        assert set(l) == set([])
+
+        s, t = self.mvs.read_edge(e)
+        assert s == None
+        assert t == None
+
+        l = self.mvs.read_outgoing(e)
+        assert l == None
+
+        l = self.mvs.read_incoming(e)
+        assert l == None
+
+        s, t = self.mvs.read_edge(g)
+        assert s == None
+        assert t == None
+
+        l = self.mvs.read_outgoing(g)
+        assert l == None
+
+        l = self.mvs.read_incoming(g)
+        assert l == None
+
+        l = self.mvs.read_outgoing(f)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(f)
+        assert l != None
+        assert set(l) == set([])
+
+        s, t = self.mvs.read_edge(h)
+        assert s == b
+        assert t == c
+
+        n = self.mvs.delete_edge(d)
+        assert n == None
+
+        l = self.mvs.read_outgoing(a)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(a)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_outgoing(b)
+        assert l != None
+        assert set(l) == set([h])
+
+        l = self.mvs.read_incoming(b)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_outgoing(c)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(c)
+        assert l != None
+        assert set(l) == set([h])
+
+        s, t = self.mvs.read_edge(d)
+        assert s == None
+        assert t == None
+
+        l = self.mvs.read_outgoing(d)
+        assert l == None
+
+        l = self.mvs.read_incoming(d)
+        assert l == None
+
+        s, t = self.mvs.read_edge(e)
+        assert s == None
+        assert t == None
+
+        l = self.mvs.read_outgoing(e)
+        assert l == None
+
+        l = self.mvs.read_incoming(e)
+        assert l == None
+
+        s, t = self.mvs.read_edge(g)
+        assert s == None
+        assert t == None
+
+        l = self.mvs.read_outgoing(g)
+        assert l == None
+
+        l = self.mvs.read_incoming(g)
+        assert l == None
+
+        l = self.mvs.read_outgoing(f)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(f)
+        assert l != None
+        assert set(l) == set([])
+
+        s, t = self.mvs.read_edge(h)
+        assert s == b
+        assert t == c

state/test/test_delete_node.py

@@ -1,249 +1,215 @@
 import unittest
 from modelverse_state.main import ModelverseState
 
-from modelverse_state import status
-
 class TestDeleteNode(unittest.TestCase):
     def setUp(self):
         self.mvs = ModelverseState()
 
     def test_delete_node_no_exists(self):
-        n, r = self.mvs.delete_node(-1)
-        self.assertEquals(r, status.FAIL_DN_UNKNOWN)
+        n = self.mvs.delete_node(-1)
+        assert n == None
 
     def test_delete_node_no_value(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
 
-        n, r = self.mvs.delete_node(a)
-        self.assertEquals(r, status.SUCCESS)
+        n = self.mvs.delete_node(a)
+        assert n == None
 
     def test_delete_node_value(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_nodevalue(1)
+        assert a != None
 
-        d, r = self.mvs.read_value(a)
-        self.assertEquals(d, 1)
-        self.assertEquals(r, status.SUCCESS)
+        d = self.mvs.read_value(a)
+        assert d == 1
 
-        n, r = self.mvs.delete_node(a)
-        self.assertEquals(r, status.SUCCESS)
+        n = self.mvs.delete_node(a)
+        assert n == None
 
-        d, r = self.mvs.read_value(a)
-        self.assertEquals(r, status.FAIL_RV_UNKNOWN)
+        d = self.mvs.read_value(a)
+        assert d == None
         self.assertEquals(d, None)
 
     def test_delete_node_edge(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
 
-        n, r = self.mvs.delete_node(c)
-        self.assertEquals(r, status.FAIL_DN_UNKNOWN)
+        n = self.mvs.delete_node(c)
+        assert n == None
 
     def test_delete_node_remove_edge_outgoing(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        n, r = self.mvs.delete_node(a)
-        self.assertEquals(r, status.SUCCESS)
-
-        d, r = self.mvs.read_value(a)
-        self.assertEquals(r, status.FAIL_RV_UNKNOWN)
-        self.assertEquals(d, None)
+        a = self.mvs.create_nodevalue(1)
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
 
-        v, r = self.mvs.read_edge(c)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
+        n = self.mvs.delete_node(a)
+        assert n == None
 
-        d, r = self.mvs.read_outgoing(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(len(d), 0)
-        self.assertEquals(set(d), set())
+        d = self.mvs.read_value(a)
+        assert d == None
 
-    def test_delete_node_remove_edge_incoming(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(b, a)
-        self.assertEquals(r, status.SUCCESS)
-
-        n, r = self.mvs.delete_node(a)
-        self.assertEquals(r, status.SUCCESS)
-
-        d, r = self.mvs.read_value(a)
-        self.assertEquals(r, status.FAIL_RV_UNKNOWN)
-        self.assertEquals(d, None)
+        s, t = self.mvs.read_edge(c)
+        assert s == None
+        assert t == None
 
-        v, r = self.mvs.read_edge(c)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
+        d = self.mvs.read_outgoing(b)
+        assert d != None
+        assert set(d) == set([])
 
-        d, r = self.mvs.read_outgoing(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(len(d), 0)
-        self.assertEquals(set(d), set())
+    def test_delete_node_remove_edge_incoming(self):
+        a = self.mvs.create_nodevalue(1)
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(b, a)
+        assert a != None
+        assert b != None
+        assert c != None
 
-    def test_delete_node_remove_edge_both(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        f, r = self.mvs.create_edge(e, a)
-        self.assertEquals(r, status.SUCCESS)
-
-        n, r = self.mvs.delete_node(a)
-        self.assertEquals(r, status.SUCCESS)
-
-        d, r = self.mvs.read_value(a)
-        self.assertEquals(r, status.FAIL_RV_UNKNOWN)
-        self.assertEquals(d, None)
+        n = self.mvs.delete_node(a)
+        assert n == None
 
-        v, r = self.mvs.read_edge(c)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
+        d = self.mvs.read_value(a)
+        assert d == None
 
-        d, r = self.mvs.read_incoming(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(len(d), 0)
-        self.assertEquals(set(d), set())
+        s, t = self.mvs.read_edge(c)
+        assert s == None
+        assert t == None
 
-        v, r = self.mvs.read_edge(f)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
+        d = self.mvs.read_outgoing(b)
+        assert d != None
+        assert set(d) == set([])
 
-        d, r = self.mvs.read_outgoing(e)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(len(d), 0)
-        self.assertEquals(set(d), set())
+    def test_delete_node_remove_edge_both(self):
+        a = self.mvs.create_nodevalue(1)
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        e = self.mvs.create_node()
+        f = self.mvs.create_edge(e, a)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert e != None
+        assert f != None
+
+        n = self.mvs.delete_node(a)
+        assert n == None
+
+        d = self.mvs.read_value(a)
+        assert d == None
+
+        s, t = self.mvs.read_edge(c)
+        assert s == None
+        assert t == None
+
+        d = self.mvs.read_incoming(b)
+        assert d != None
+        assert set(d) == set([])
+
+        s, t = self.mvs.read_edge(f)
+        assert s == None
+        assert t == None
+
+        d = self.mvs.read_outgoing(e)
+        assert d != None
+        assert set(d) == set([])
 
     def test_delete_node_remove_edge_recursive(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(c, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        n, r = self.mvs.delete_node(a)
-        self.assertEquals(r, status.SUCCESS)
-
-        d, r = self.mvs.read_value(a)
-        self.assertEquals(r, status.FAIL_RV_UNKNOWN)
-        self.assertEquals(d, None)
+        a = self.mvs.create_nodevalue(1)
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        d = self.mvs.create_edge(c, b)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+
+        n = self.mvs.delete_node(a)
+        assert n == None
+
+        d = self.mvs.read_value(a)
+        assert d == None
 
-        v, r = self.mvs.read_edge(c)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
+        s, t = self.mvs.read_edge(c)
+        assert s == None
+        assert t == None
 
-        v, r = self.mvs.read_edge(d)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
+        s, t = self.mvs.read_edge(d)
+        assert s == None
+        assert t == None
 
-        d, r = self.mvs.read_outgoing(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(len(d), 0)
-        self.assertEquals(set(d), set())
+        d = self.mvs.read_outgoing(b)
+        assert d != None
+        assert set(d) == set([])
 
     def test_delete_node_remove_edge_recursive_deep(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-        f, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        g, r = self.mvs.create_edge(f, e)
-        self.assertEquals(r, status.SUCCESS)
-        h, r = self.mvs.create_edge(b, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        n, r = self.mvs.delete_node(a)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(a)
-        self.assertEquals(r, status.FAIL_RO_UNKNOWN)
-        self.assertEquals(l, None)
-
-        l, r = self.mvs.read_incoming(a)
-        self.assertEquals(r, status.FAIL_RI_UNKNOWN)
-        self.assertEquals(l, None)
-
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([h]))
-
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_outgoing(c)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(c)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([h]))
-
-        v, r = self.mvs.read_edge(d)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-
-        v, r = self.mvs.read_edge(e)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-
-        v, r = self.mvs.read_edge(g)
-        s, t = v
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-
-        l, r = self.mvs.read_outgoing(f)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        l, r = self.mvs.read_incoming(f)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set())
-
-        v, r = self.mvs.read_edge(h)
-        s, t = v
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(s, b)
-        self.assertEquals(t, c)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_node()
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(d, c)
+        f = self.mvs.create_node()
+        g = self.mvs.create_edge(f, e)
+        h = self.mvs.create_edge(b, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+        assert f != None
+        assert g != None
+        assert h != None
+
+        n = self.mvs.delete_node(a)
+        assert n == None
+
+        l = self.mvs.read_outgoing(a)
+        assert l == None
+
+        l = self.mvs.read_incoming(a)
+        assert l == None
+
+        l = self.mvs.read_outgoing(b)
+        assert l != None
+        assert set(l) == set([h])
+
+        l = self.mvs.read_incoming(b)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_outgoing(c)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(c)
+        assert l != None
+        assert set(l) == set([h])
+
+        s, t = self.mvs.read_edge(d)
+        assert s == None
+        assert t == None
+
+        s, t = self.mvs.read_edge(e)
+        assert s == None
+        assert t == None
+
+        s, t = self.mvs.read_edge(g)
+        assert s == None
+        assert t == None
+
+        l = self.mvs.read_outgoing(f)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(f)
+        assert l != None
+        assert set(l) == set([])
+
+        s, t = self.mvs.read_edge(h)
+        assert s == b
+        assert t == c

state/test/test_read_dict.py

@@ -1,150 +1,91 @@
 import unittest
 from modelverse_state.main import ModelverseState
 
-from modelverse_state import status
-
 class TestReadDict(unittest.TestCase):
     def setUp(self):
         self.mvs = ModelverseState()
 
     def test_read_dict_no_exists(self):
-        l, r = self.mvs.read_dict(-1, "abc")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICT_UNKNOWN)
+        l = self.mvs.read_dict(-1, "abc")
+        assert l == None
 
     def test_read_dict_not_found_node(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
 
         # Passing data is not enforced, as the data will be interpreted if necessary
-        l, r = self.mvs.read_dict(a, "abc")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICT_NOT_FOUND)
+        l = self.mvs.read_dict(a, "abc")
+        assert l == None
 
     def test_read_dict_not_found_nodevalue(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_nodevalue(1)
+        assert a != None
 
         # Passing data is not enforced, as the data will be interpreted if necessary
-        l, r = self.mvs.read_dict(a, "abc")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICT_NOT_FOUND)
+        l = self.mvs.read_dict(a, "abc")
+        assert l == None
 
     def test_read_dict_not_found_edge(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
 
         # Passing data is not enforced, as the data will be interpreted if necessary
-        l, r = self.mvs.read_dict(c, "abc")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICT_NOT_FOUND)
+        l = self.mvs.read_dict(c, "abc")
+        assert l == None
 
     def test_read_dict_no_primitive(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
 
         # Passing data is not enforced, as the data will be interpreted if necessary
-        l, r = self.mvs.read_dict(a, a)
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICT_NOT_FOUND)
+        l = self.mvs.read_dict(a, a)
+        assert l == None
 
     def test_read_dict_node_simple(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_nodevalue("f")
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_dict(a, "f")
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(l, b)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_nodevalue("f")
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(d, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        l = self.mvs.read_dict(a, "f")
+        assert l == b
 
     def test_read_dict_node_multi(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_nodevalue("f")
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        g, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        h, r = self.mvs.create_nodevalue("k")
-        self.assertEquals(r, status.SUCCESS)
-        i, r = self.mvs.create_edge(a, g)
-        self.assertEquals(r, status.SUCCESS)
-        j, r = self.mvs.create_edge(i, h)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_dict(a, "f")
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(l, b)
-
-        l, r = self.mvs.read_dict(a, "k")
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(l, g)
-
-        l, r = self.mvs.read_dict(a, "l")
-        self.assertEquals(r, status.FAIL_RDICT_NOT_FOUND)
-        self.assertEquals(l, None)
-
-    """
-    def test_read_dict_node_uncertain(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_nodevalue("f")
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        h, r = self.mvs.create_nodevalue("g")
-        self.assertEquals(r, status.SUCCESS)
-        i, r = self.mvs.create_edge(d, h)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_dict(a, "f")
-        self.assertEquals(r, status.FAIL_RDICT_UNCERTAIN)
-        self.assertEquals(l, None)
-
-    def test_read_dict_node_multi_ambiguous(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_nodevalue("f")
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        g, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        h, r = self.mvs.create_nodevalue("f")
-        self.assertEquals(r, status.SUCCESS)
-        i, r = self.mvs.create_edge(a, g)
-        self.assertEquals(r, status.SUCCESS)
-        j, r = self.mvs.create_edge(i, h)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_dict(a, "f")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICT_AMBIGUOUS)
-    """
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_nodevalue("f")
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(d, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        g = self.mvs.create_node()
+        h = self.mvs.create_nodevalue("k")
+        i = self.mvs.create_edge(a, g)
+        j = self.mvs.create_edge(i, h)
+        assert g != None
+        assert h != None
+        assert i != None
+        assert j != None
+
+        l = self.mvs.read_dict(a, "f")
+        assert l == b
+
+        l = self.mvs.read_dict(a, "k")
+        assert l == g
+
+        l = self.mvs.read_dict(a, "l")
+        assert l == None

state/test/test_read_dict_edge.py

@@ -1,125 +1,91 @@
 import unittest
 from modelverse_state.main import ModelverseState
 
-from modelverse_state import status
-
 class TestReadDictEdge(unittest.TestCase):
     def setUp(self):
         self.mvs = ModelverseState()
 
     def test_read_dict_edge_no_exists(self):
-        l, r = self.mvs.read_dict_edge(-1, "abc")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICTE_UNKNOWN)
+        l = self.mvs.read_dict_edge(-1, "abc")
+        assert l == None
 
     def test_read_dict_edge_not_found_node(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
 
         # Passing data is not enforced, as the data will be interpreted if necessary
-        l, r = self.mvs.read_dict_edge(a, "abc")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICTE_NOT_FOUND)
+        l = self.mvs.read_dict_edge(a, "abc")
+        assert l == None
 
     def test_read_dict_edge_not_found_nodevalue(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_nodevalue(1)
+        assert a != None
 
         # Passing data is not enforced, as the data will be interpreted if necessary
-        l, r = self.mvs.read_dict_edge(a, "abc")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICTE_NOT_FOUND)
+        l = self.mvs.read_dict_edge(a, "abc")
+        assert l == None
 
     def test_read_dict_edge_not_found_edge(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
 
         # Passing data is not enforced, as the data will be interpreted if necessary
-        l, r = self.mvs.read_dict_edge(c, "abc")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICTE_NOT_FOUND)
+        l = self.mvs.read_dict_edge(c, "abc")
+        assert l == None
 
     def test_read_dict_edge_no_primitive(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
 
         # Passing data is not enforced, as the data will be interpreted if necessary
-        l, r = self.mvs.read_dict_edge(a, a)
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICTE_NOT_FOUND)
+        l = self.mvs.read_dict_edge(a, a)
+        assert l == None
 
     def test_read_dict_edge_node_simple(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_nodevalue("f")
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_dict_edge(a, "f")
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(l, d)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_nodevalue("f")
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(d, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        l = self.mvs.read_dict_edge(a, "f")
+        assert l == d
 
     def test_read_dict_edge_node_multi(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_nodevalue("f")
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        g, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        h, r = self.mvs.create_nodevalue("k")
-        self.assertEquals(r, status.SUCCESS)
-        i, r = self.mvs.create_edge(a, g)
-        self.assertEquals(r, status.SUCCESS)
-        j, r = self.mvs.create_edge(i, h)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_dict_edge(a, "f")
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(l, d)
-
-        l, r = self.mvs.read_dict_edge(a, "k")
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(l, i)
-
-        l, r = self.mvs.read_dict_edge(a, "l")
-        self.assertEquals(r, status.FAIL_RDICTE_NOT_FOUND)
-        self.assertEquals(l, None)
-
-    """
-    def test_read_dict_edge_node_uncertain(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_nodevalue("f")
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        h, r = self.mvs.create_nodevalue("g")
-        self.assertEquals(r, status.SUCCESS)
-        i, r = self.mvs.create_edge(d, h)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_dict_edge(a, "f")
-        self.assertEquals(r, status.FAIL_RDICTE_UNCERTAIN)
-        self.assertEquals(l, None)
-    """
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_nodevalue("f")
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(d, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        g = self.mvs.create_node()
+        h = self.mvs.create_nodevalue("k")
+        i = self.mvs.create_edge(a, g)
+        j = self.mvs.create_edge(i, h)
+        assert g != None
+        assert h != None
+        assert i != None
+        assert j != None
+
+        l = self.mvs.read_dict_edge(a, "f")
+        assert l == d
+
+        l = self.mvs.read_dict_edge(a, "k")
+        assert l == i
+
+        l = self.mvs.read_dict_edge(a, "l")
+        assert l == None

state/test/test_read_dict_keys.py

@@ -1,54 +1,51 @@
 import unittest
 from modelverse_state.main import ModelverseState
 
-from modelverse_state import status
-
 class TestReadKeys(unittest.TestCase):
     def setUp(self):
         self.mvs = ModelverseState()
 
     def test_read_dict_keys_no_exists(self):
-        l, r = self.mvs.read_dict_keys(100000)
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICTKEYS_UNKNOWN)
+        l = self.mvs.read_dict_keys(100000)
+        assert l == None
 
     def test_read_dict_keys_simple(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_nodevalue("f")
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_dict_keys(a)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([c]))
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_nodevalue("f")
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(d, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        l = self.mvs.read_dict_keys(a)
+        assert l != None
+        assert set(l) == set([c])
 
     def test_read_dict_keys_multi(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_nodevalue("f")
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        g, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        h, r = self.mvs.create_nodevalue("k")
-        self.assertEquals(r, status.SUCCESS)
-        i, r = self.mvs.create_edge(a, g)
-        self.assertEquals(r, status.SUCCESS)
-        j, r = self.mvs.create_edge(i, h)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_dict_keys(a)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(set(l), set([c, h]))
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_nodevalue("f")
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(d, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        g = self.mvs.create_node()
+        h = self.mvs.create_nodevalue("k")
+        i = self.mvs.create_edge(a, g)
+        j = self.mvs.create_edge(i, h)
+        assert g != None
+        assert h != None
+        assert i != None
+        assert j != None
+
+        l = self.mvs.read_dict_keys(a)
+        assert l != None
+        assert set(l) == set([c, h])

state/test/test_read_dict_node.py

@@ -1,126 +1,72 @@
 import unittest
 from modelverse_state.main import ModelverseState
 
-from modelverse_state import status
-
 class TestReadDictNode(unittest.TestCase):
     def setUp(self):
         self.mvs = ModelverseState()
 
     def test_read_dict_node_no_exists(self):
-        l, r = self.mvs.read_dict_node(-1, "abc")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICTN_UNKNOWN)
+        l = self.mvs.read_dict_node(-1, "abc")
+        assert l == None
 
     def test_read_dict_node_not_found_edge(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
 
         # Passing data is not enforced, as the data will be interpreted if necessary
-        l, r = self.mvs.read_dict_node(c, "abc")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICTN_NOT_FOUND)
+        l = self.mvs.read_dict_node(c, "abc")
+        assert l == None
 
     def test_read_dict_node_no_primitive(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
 
         # Passing data is not enforced, as the data will be interpreted if necessary
-        l, r = self.mvs.read_dict_node(a, a)
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICTN_NOT_FOUND)
+        l = self.mvs.read_dict_node(a, a)
+        assert l == None
 
     def test_read_dict_node_node_simple(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_dict_node(a, c)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(l, b)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_node()
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(d, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        l = self.mvs.read_dict_node(a, c)
+        assert l == b
 
     def test_read_dict_node_multi(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        g, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        h, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        i, r = self.mvs.create_edge(a, g)
-        self.assertEquals(r, status.SUCCESS)
-        j, r = self.mvs.create_edge(i, h)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_dict_node(a, c)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(l, b)
-
-        l, r = self.mvs.read_dict_node(a, h)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(l, g)
-
-    """
-    def test_read_dict_node_uncertain(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        h, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        i, r = self.mvs.create_edge(d, h)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_dict_node(a, c)
-        self.assertEquals(r, status.FAIL_RDICTN_UNCERTAIN)
-        self.assertEquals(l, None)
-
-    def test_read_dict_node_multi_ambiguous(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        g, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        i, r = self.mvs.create_edge(a, g)
-        self.assertEquals(r, status.SUCCESS)
-        j, r = self.mvs.create_edge(i, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_dict_node(a, c)
-        self.assertEquals(r, status.FAIL_RDICTN_AMBIGUOUS)
-        self.assertEquals(l, None)
-    """
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_node()
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(d, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        g = self.mvs.create_node()
+        h = self.mvs.create_node()
+        i = self.mvs.create_edge(a, g)
+        j = self.mvs.create_edge(i, h)
+        assert g != None
+        assert h != None
+        assert i != None
+        assert j != None
+
+        l = self.mvs.read_dict_node(a, c)
+        assert l == b
+
+        l = self.mvs.read_dict_node(a, h)
+        assert l == g

state/test/test_read_edge.py

@@ -1,151 +1,123 @@
 import unittest
 from modelverse_state.main import ModelverseState
 
-from modelverse_state import status
-
 class TestReadEdge(unittest.TestCase):
     def setUp(self):
         self.mvs = ModelverseState()
 
     def test_read_edge_node(self):
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        b = self.mvs.create_node()
+        assert b != None
 
-        v, r = self.mvs.read_edge(b)
-        s, t = v
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
+        s, t = self.mvs.read_edge(b)
+        assert s == None
+        assert t == None
 
     def test_read_edge_no_exists(self):
-        v, r = self.mvs.read_edge(-1)
-        s, t = v
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
+        s, t = self.mvs.read_edge(-1)
+        assert s == None
+        assert t == None
 
     def test_read_edge_nodevalue(self):
-        b, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
+        b = self.mvs.create_nodevalue(1)
+        assert b != None
 
-        v, r = self.mvs.read_edge(-1)
-        s, t = v
-        self.assertEquals(s, None)
-        self.assertEquals(t, None)
-        self.assertEquals(r, status.FAIL_RE_UNKNOWN)
+        s, t = self.mvs.read_edge(b)
+        assert s == None
+        assert t == None
 
     def test_read_edge_normal(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        v, r = self.mvs.read_edge(c)
-        s, t = v
-        self.assertEquals(s, a)
-        self.assertEquals(t, b)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+
+        s, t = self.mvs.read_edge(c)
+        assert s == a
+        assert t == b
 
     def test_read_edge_edge_to_edge(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(c, d)
-        self.assertEquals(r, status.SUCCESS)
-
-        v, r = self.mvs.read_edge(c)
-        s, t = v
-        self.assertEquals(s, a)
-        self.assertEquals(t, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        v, r = self.mvs.read_edge(d)
-        s, t = v
-        self.assertEquals(s, a)
-        self.assertEquals(t, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        v, r = self.mvs.read_edge(e)
-        s, t = v
-        self.assertEquals(s, c)
-        self.assertEquals(t, d)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(c, d)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        s, t = self.mvs.read_edge(c)
+        assert s == a
+        assert t == b
+
+        s, t = self.mvs.read_edge(d)
+        assert s == a
+        assert t == b
+
+        s, t = self.mvs.read_edge(e)
+        assert s == c
+        assert t == d
 
     def test_read_edge_edge_to_node(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(c, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        v, r = self.mvs.read_edge(c)
-        s, t = v
-        self.assertEquals(s, a)
-        self.assertEquals(t, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        v, r = self.mvs.read_edge(d)
-        s, t = v
-        self.assertEquals(s, c)
-        self.assertEquals(t, b)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        d = self.mvs.create_edge(c, b)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+
+        s, t = self.mvs.read_edge(c)
+        assert s == a
+        assert t == b
+
+        s, t = self.mvs.read_edge(d)
+        assert s == c
+        assert t == b
 
     def test_read_edge_node_to_edge(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(b, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        v, r = self.mvs.read_edge(c)
-        s, t = v
-        self.assertEquals(s, a)
-        self.assertEquals(t, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        v, r = self.mvs.read_edge(d)
-        s, t = v
-        self.assertEquals(s, b)
-        self.assertEquals(t, c)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        d = self.mvs.create_edge(b, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+
+        s, t = self.mvs.read_edge(c)
+        assert s == a
+        assert t == b
+
+        s, t = self.mvs.read_edge(d)
+        assert s == b
+        assert t == c
 
     def test_read_edge_node_to_nodevalue(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        v, r = self.mvs.read_edge(c)
-        s, t = v
-        self.assertEquals(s, a)
-        self.assertEquals(t, b)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_nodevalue(1)
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+
+        s, t = self.mvs.read_edge(c)
+        assert s == a
+        assert t == b
 
     def test_read_edge_nodevalue_to_nodevalue(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        v, r = self.mvs.read_edge(c)
-        s, t = v
-        self.assertEquals(s, a)
-        self.assertEquals(t, b)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_nodevalue(1)
+        b = self.mvs.create_nodevalue(1)
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+
+        s, t = self.mvs.read_edge(c)
+        assert s == a
+        assert t == b

state/test/test_read_incoming.py

@@ -1,279 +1,252 @@
 import unittest
 from modelverse_state.main import ModelverseState
 
-from modelverse_state import status
-
 class TestReadIncoming(unittest.TestCase):
     def setUp(self):
         self.mvs = ModelverseState()
 
     def test_read_incoming_node_none(self):
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        b = self.mvs.create_node()
+        assert b != None
 
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        l = self.mvs.read_incoming(b)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_incoming_node_one(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(a)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(len(l), 1)
-        self.assertEquals(set(l), set([c]))
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+
+        l = self.mvs.read_incoming(a)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(b)
+        assert l != None
+        assert set(l) == set([c])
 
     def test_read_incoming_node_multi(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(a)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(len(l), 3)
-        self.assertEquals(set(l), set([c, d, e]))
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        l = self.mvs.read_incoming(a)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(b)
+        assert l != None
+        assert set(l) == set([c, d, e])
 
     def test_read_incoming_node_multi_others_unaffected(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        f, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(a)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(len(l), 3)
-        self.assertEquals(set(l), set([c, d, e]))
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(f)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        f = self.mvs.create_node()
+        assert f != None
+
+        l = self.mvs.read_incoming(a)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(b)
+        assert l != None
+        assert set(l) == set([c, d, e])
+
+        l = self.mvs.read_incoming(f)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_incoming_edge_none(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(c)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+
+        l = self.mvs.read_incoming(c)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_incoming_edge_one(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(c, a)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(a, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(c)
-        self.assertEquals(len(l), 1)
-        self.assertEquals(set(l), set([e]))
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(d)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(e)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        d = self.mvs.create_edge(c, a)
+        e = self.mvs.create_edge(a, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        l = self.mvs.read_incoming(c)
+        assert l != None
+        assert set(l) == set([e])
+
+        l = self.mvs.read_incoming(d)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(e)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_incoming_edge_multi(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, c)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(b, c)
-        self.assertEquals(r, status.SUCCESS)
-        f, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(len(l), 1)
-        self.assertEquals(set(l), set([c]))
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(c)
-        self.assertEquals(len(l), 3)
-        self.assertEquals(set(l), set([d, e, f]))
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(d)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(e)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(f)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        d = self.mvs.create_edge(a, c)
+        e = self.mvs.create_edge(b, c)
+        f = self.mvs.create_edge(d, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+        assert f != None
+
+        l = self.mvs.read_incoming(b)
+        assert l != None
+        assert set(l) == set([c])
+
+        l = self.mvs.read_incoming(c)
+        assert l != None
+        assert set(l) == set([d, e, f])
+
+        l = self.mvs.read_incoming(d)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(e)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(f)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_incoming_nodevalue_none(self):
-        b, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
+        b = self.mvs.create_nodevalue(1)
+        assert b != None
 
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        l = self.mvs.read_incoming(b)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_incoming_nodevalue_one(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(b, a)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(a)
-        self.assertEquals(len(l), 1)
-        self.assertEquals(set(l), set([c]))
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_nodevalue(1)
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(b, a)
+        assert a != None
+        assert b != None
+        assert c != None
+
+        l = self.mvs.read_incoming(a)
+        assert l != None
+        assert set(l) == set([c])
+
+        l = self.mvs.read_incoming(b)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_incoming_nodevalue_multi(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(b, a)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(b, a)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(b, a)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(a)
-        self.assertEquals(len(l), 3)
-        self.assertEquals(set(l), set([c, d, e]))
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_nodevalue(1)
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(b, a)
+        d = self.mvs.create_edge(b, a)
+        e = self.mvs.create_edge(b, a)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        l = self.mvs.read_incoming(a)
+        assert l != None
+        assert set(l) == set([c, d, e])
+
+        l = self.mvs.read_incoming(b)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_incoming_nodevalue_multi_others_unaffected(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(b, a)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(b, a)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(b, a)
-        self.assertEquals(r, status.SUCCESS)
-
-        f, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(a)
-        self.assertEquals(len(l), 3)
-        self.assertEquals(set(l), set([c, d, e]))
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(f)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_nodevalue(1)
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(b, a)
+        d = self.mvs.create_edge(b, a)
+        e = self.mvs.create_edge(b, a)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        f = self.mvs.create_nodevalue(1)
+        assert f != None
+
+        l = self.mvs.read_incoming(a)
+        assert l != None
+        assert set(l) == set([c, d, e])
+
+        l = self.mvs.read_incoming(b)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_incoming(f)
+        assert l != None
+        assert set(l) == set([])
     
     def test_read_incoming_node_deleted(self):
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        n, r = self.mvs.delete_node(b)
-        self.assertEquals(r, status.SUCCESS)
+        b = self.mvs.create_node()
+        assert b != None
 
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RI_UNKNOWN)
+        n = self.mvs.delete_node(b)
+        assert n == None
+
+        l = self.mvs.read_incoming(b)
+        assert l == None
 
     def test_read_incoming_nodevalue_deleted(self):
-        b, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        n, r = self.mvs.delete_node(b)
-        self.assertEquals(r, status.SUCCESS)
+        b = self.mvs.create_nodevalue(1)
+        assert b != None
+
+        n = self.mvs.delete_node(b)
+        assert n == None
 
-        l, r = self.mvs.read_incoming(b)
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RI_UNKNOWN)
+        l = self.mvs.read_incoming(b)
+        assert l == None
 
     def test_read_incoming_edge_deleted(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        n, r = self.mvs.delete_edge(c)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_incoming(c)
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RI_UNKNOWN)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+
+        n = self.mvs.delete_edge(c)
+        assert n == None
+
+        l = self.mvs.read_incoming(c)
+        assert l == None

state/test/test_read_outgoing.py

@@ -1,267 +1,242 @@
 import unittest
 from modelverse_state.main import ModelverseState
 
-from modelverse_state import status
-
 class TestReadOutgoing(unittest.TestCase):
     def setUp(self):
         self.mvs = ModelverseState()
 
     def test_read_outgoing_node_none(self):
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        b = self.mvs.create_node()
+        assert b != None
 
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        l = self.mvs.read_outgoing(b)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_outgoing_node_one(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(a)
-        self.assertEquals(len(l), 1)
-        self.assertEquals(set(l), set([c]))
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+
+        l = self.mvs.read_outgoing(a)
+        assert l != None
+        assert set(l) == set([c])
+
+        l = self.mvs.read_outgoing(b)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_outgoing_node_multi(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(a)
-        self.assertEquals(len(l), 3)
-        self.assertEquals(set(l), set([c, d, e]))
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        l = self.mvs.read_outgoing(a)
+        assert l != None
+        assert set(l) == set([c, d, e])
+
+        l = self.mvs.read_outgoing(b)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_outgoing_node_multi_others_unaffected(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        f, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(a)
-        self.assertEquals(len(l), 3)
-        self.assertEquals(set(l), set([c, d, e]))
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(f)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        f = self.mvs.create_node()
+        assert f != None
+
+        l = self.mvs.read_outgoing(a)
+        assert l != None
+        assert set(l) == set([c, d, e])
+
+        l = self.mvs.read_outgoing(b)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_outgoing(f)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_outgoing_edge_none(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(c)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+
+        l = self.mvs.read_outgoing(c)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_outgoing_edge_one(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(c, a)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(c)
-        self.assertEquals(len(l), 1)
-        self.assertEquals(set(l), set([d]))
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(d)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        d = self.mvs.create_edge(c, a)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+
+        l = self.mvs.read_outgoing(c)
+        assert l != None
+        assert set(l) == set([d])
+
+        l = self.mvs.read_outgoing(d)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_outgoing_edge_multi(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(c, a)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(c, b)
-        self.assertEquals(r, status.SUCCESS)
-        f, r = self.mvs.create_edge(c, d)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(c)
-        self.assertEquals(len(l), 3)
-        self.assertEquals(set(l), set([d, e, f]))
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(d)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(e)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(f)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        d = self.mvs.create_edge(c, a)
+        e = self.mvs.create_edge(c, b)
+        f = self.mvs.create_edge(c, d)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+        assert f != None
+
+        l = self.mvs.read_outgoing(c)
+        assert l != None
+        assert set(l) == set([d, e, f])
+
+        l = self.mvs.read_outgoing(d)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_outgoing(e)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_outgoing(f)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_outgoing_nodevalue_none(self):
-        b, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
+        b = self.mvs.create_nodevalue(1)
+        assert b != None
 
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        l = self.mvs.read_outgoing(b)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_outgoing_nodevalue_one(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(a)
-        self.assertEquals(len(l), 1)
-        self.assertEquals(set(l), set([c]))
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_nodevalue(1)
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+
+        l = self.mvs.read_outgoing(a)
+        assert l != None
+        assert set(l) == set([c])
+
+        l = self.mvs.read_outgoing(b)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_outgoing_nodevalue_multi(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(a)
-        self.assertEquals(len(l), 3)
-        self.assertEquals(set(l), set([c, d, e]))
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_nodevalue(1)
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        l = self.mvs.read_outgoing(a)
+        assert l != None
+        assert set(l) == set([c, d, e])
+
+        l = self.mvs.read_outgoing(b)
+        assert l != None
+        assert set(l) == set([])
 
     def test_read_outgoing_nodevalue_multi_others_unaffected(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-
-        f, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(a)
-        self.assertEquals(len(l), 3)
-        self.assertEquals(set(l), set([c, d, e]))
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(f)
-        self.assertEquals(len(l), 0)
-        self.assertEquals(set(l), set())
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_nodevalue(1)
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        f = self.mvs.create_nodevalue(1)
+        assert f != None
+
+        l = self.mvs.read_outgoing(a)
+        assert l != None
+        assert set(l) == set([c, d, e])
+
+        l = self.mvs.read_outgoing(b)
+        assert l != None
+        assert set(l) == set([])
+
+        l = self.mvs.read_outgoing(f)
+        assert l != None
+        assert set(l) == set([])
     
     def test_read_outgoing_node_deleted(self):
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        n, r = self.mvs.delete_node(b)
-        self.assertEquals(r, status.SUCCESS)
+        b = self.mvs.create_node()
+        assert b != None
 
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RO_UNKNOWN)
+        n = self.mvs.delete_node(b)
+        assert n == None
+
+        l = self.mvs.read_outgoing(b)
+        assert l == None
 
     def test_read_outgoing_nodevalue_deleted(self):
-        b, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
-        n, r = self.mvs.delete_node(b)
-        self.assertEquals(r, status.SUCCESS)
+        b = self.mvs.create_nodevalue(1)
+        assert b != None
+
+        n = self.mvs.delete_node(b)
+        assert n == None
 
-        l, r = self.mvs.read_outgoing(b)
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RO_UNKNOWN)
+        l = self.mvs.read_outgoing(b)
+        assert l == None
 
     def test_read_outgoing_edge_deleted(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        n, r = self.mvs.delete_edge(c)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_outgoing(c)
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RO_UNKNOWN)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
+
+        n = self.mvs.delete_edge(c)
+        assert n == None
+
+        l = self.mvs.read_outgoing(c)
+        assert l == None

state/test/test_read_reverse_dict.py

@@ -1,164 +1,154 @@
 import unittest
 from modelverse_state.main import ModelverseState
 
-from modelverse_state import status
-
 class TestReadReverseDict(unittest.TestCase):
     def setUp(self):
         self.mvs = ModelverseState()
 
     def test_read_reverse_dict_no_exists(self):
-        l, r = self.mvs.read_reverse_dict(-1, "abc")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RRDICT_UNKNOWN)
+        l = self.mvs.read_reverse_dict(-1, "abc")
+        assert l == None
 
     def test_read_reverse_dict_not_found_node(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
 
         # Passing data is not enforced, as the data will be interpreted if necessary
-        l, r = self.mvs.read_reverse_dict(a, "abc")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RRDICT_NOT_FOUND)
+        l = self.mvs.read_reverse_dict(a, "abc")
+        assert l == None
 
     def test_read_reverse_dict_not_found_nodevalue(self):
-        a, r = self.mvs.create_nodevalue(1)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_nodevalue(1)
+        assert a != None
 
         # Passing data is not enforced, as the data will be interpreted if necessary
-        l, r = self.mvs.read_reverse_dict(a, "abc")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RRDICT_NOT_FOUND)
+        l = self.mvs.read_reverse_dict(a, "abc")
+        assert l == None
 
     def test_read_reverse_dict_not_found_edge(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_edge(a, b)
+        assert a != None
+        assert b != None
+        assert c != None
 
         # Passing data is not enforced, as the data will be interpreted if necessary
-        l, r = self.mvs.read_reverse_dict(c, "abc")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RRDICT_NOT_FOUND)
+        l = self.mvs.read_reverse_dict(c, "abc")
+        assert l == None
 
     def test_read_reverse_dict_no_primitive(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
+        a = self.mvs.create_node()
+        assert a != None
 
         # Passing data is not enforced, as the data will be interpreted if necessary
-        l, r = self.mvs.read_reverse_dict(a, a)
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RRDICT_NOT_FOUND)
+        l = self.mvs.read_reverse_dict(a, a)
+        assert l == None
 
     def test_read_reverse_dict_node_simple(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_nodevalue("f")
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_reverse_dict(b, "f")
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(l, [a])
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_nodevalue("f")
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(d, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        l = self.mvs.read_reverse_dict(b, "f")
+        assert l != None
+        assert set(l) == set([a])
 
     def test_read_reverse_dict_no_match(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_nodevalue("g")
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_reverse_dict(b, "f")
-        self.assertEquals(r, status.FAIL_RRDICT_NOT_FOUND)
-        self.assertEquals(l, None)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_nodevalue("g")
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(d, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        l = self.mvs.read_reverse_dict(b, "f")
+        assert l == None
 
     def test_read_reverse_dict_node_multi(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_nodevalue("f")
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        g, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        h, r = self.mvs.create_nodevalue("k")
-        self.assertEquals(r, status.SUCCESS)
-        i, r = self.mvs.create_edge(a, g)
-        self.assertEquals(r, status.SUCCESS)
-        j, r = self.mvs.create_edge(i, h)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_reverse_dict(b, "f")
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(l, [a])
-
-        l, r = self.mvs.read_reverse_dict(g, "k")
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(l, [a])
-
-        l, r = self.mvs.read_reverse_dict(a, "l")
-        self.assertEquals(r, status.FAIL_RRDICT_NOT_FOUND)
-        self.assertEquals(l, None)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_nodevalue("f")
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(d, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        g = self.mvs.create_node()
+        h = self.mvs.create_nodevalue("k")
+        i = self.mvs.create_edge(a, g)
+        j = self.mvs.create_edge(i, h)
+        assert g != None
+        assert h != None
+        assert i != None
+        assert j != None
+
+        l = self.mvs.read_reverse_dict(b, "f")
+        assert l != None
+        assert set(l) == set([a])
+
+        l = self.mvs.read_reverse_dict(g, "k")
+        assert l != None
+        assert set(l) == set([a])
+
+        l = self.mvs.read_reverse_dict(a, "l")
+        assert l == None
 
     def test_read_reverse_dict_node_multi_ambiguous(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_nodevalue("f")
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(b, a)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        g, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        h, r = self.mvs.create_nodevalue("f")
-        self.assertEquals(r, status.SUCCESS)
-        i, r = self.mvs.create_edge(g, a)
-        self.assertEquals(r, status.SUCCESS)
-        j, r = self.mvs.create_edge(i, h)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_reverse_dict(a, "f")
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(sorted(l), sorted([b, g]))
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_nodevalue("f")
+        d = self.mvs.create_edge(b, a)
+        e = self.mvs.create_edge(d, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        g = self.mvs.create_node()
+        h = self.mvs.create_nodevalue("f")
+        i = self.mvs.create_edge(g, a)
+        j = self.mvs.create_edge(i, h)
+        assert g != None
+        assert h != None
+        assert i != None
+        assert j != None
+
+        l = self.mvs.read_reverse_dict(a, "f")
+        assert l != None
+        assert set(l) == set([b, g])
 
     def test_read_reverse_dict_node_uncertain(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        b, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-        c, r = self.mvs.create_nodevalue("f")
-        self.assertEquals(r, status.SUCCESS)
-        d, r = self.mvs.create_edge(a, b)
-        self.assertEquals(r, status.SUCCESS)
-        e, r = self.mvs.create_edge(d, c)
-        self.assertEquals(r, status.SUCCESS)
-
-        h, r = self.mvs.create_nodevalue("g")
-        self.assertEquals(r, status.SUCCESS)
-        i, r = self.mvs.create_edge(d, h)
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_reverse_dict(b, "f")
-        self.assertEquals(r, status.FAIL_RRDICT_UNCERTAIN)
-        self.assertEquals(l, None)
+        a = self.mvs.create_node()
+        b = self.mvs.create_node()
+        c = self.mvs.create_nodevalue("f")
+        d = self.mvs.create_edge(a, b)
+        e = self.mvs.create_edge(d, c)
+        assert a != None
+        assert b != None
+        assert c != None
+        assert d != None
+        assert e != None
+
+        h = self.mvs.create_nodevalue("g")
+        i = self.mvs.create_edge(d, h)
+        assert h != None
+        assert i != None
+
+        l = self.mvs.read_reverse_dict(b, "f")
+        assert l == None

state/test/test_read_value.py

@@ -1,88 +1,77 @@
 import unittest
 from modelverse_state.main import ModelverseState
 
-from modelverse_state import status
-
 class TestReadValue(unittest.TestCase):
     def setUp(self):
         self.mvs = ModelverseState()
 
     def test_read_value_different_id_simple(self):
-        id1, r1 = self.mvs.create_nodevalue(1)
-        id2, r2 = self.mvs.create_nodevalue(2)
+        id1 = self.mvs.create_nodevalue(1)
+        id2 = self.mvs.create_nodevalue(2)
+        assert id1 != None
+        assert id2 != None
         
-        self.assertEquals(r1, status.SUCCESS)
-        self.assertEquals(r2, status.SUCCESS)
-
-        v1, r1 = self.mvs.read_value(id1)
-        v2, r2 = self.mvs.read_value(id2)
-        self.assertEquals(r1, status.SUCCESS)
-        self.assertEquals(r2, status.SUCCESS)
-        self.assertEquals(v1, 1)
-        self.assertEquals(v2, 2)
+        v1 = self.mvs.read_value(id1)
+        v2 = self.mvs.read_value(id2)
+        assert v1 == 1
+        assert v2 == 2
 
     def test_read_value_integer_ib_negative(self):
         # Just within range
         for i in range(-2**63, -2**63 + 10):
-            id1, r = self.mvs.create_nodevalue(i)
-            self.assertEquals(r, status.SUCCESS)
-            v, r = self.mvs.read_value(id1)
-            self.assertEquals(r, status.SUCCESS)
-            self.assertEquals(v, i)
+            id1 = self.mvs.create_nodevalue(i)
+            assert id1 != None
+
+            v = self.mvs.read_value(id1)
+            assert v == i
 
     def test_read_value_integer_ib_zero(self):
         # Nicely within range
         for i in range(-10, 10):
-            id1, r = self.mvs.create_nodevalue(i)
-            self.assertEquals(r, status.SUCCESS)
-            v, r = self.mvs.read_value(id1)
-            self.assertEquals(r, status.SUCCESS)
-            self.assertEquals(v, i)
+            id1 = self.mvs.create_nodevalue(i)
+            assert id1 != None
+
+            v = self.mvs.read_value(id1)
+            assert v == i
 
     def test_read_value_integer_ib_positive(self):
         # Just within range
         for i in range(2**64-10, 2**64):
-            id1, r = self.mvs.create_nodevalue(i)
-            self.assertEquals(r, status.SUCCESS)
-            v, r = self.mvs.read_value(id1)
-            self.assertEquals(r, status.SUCCESS)
-            self.assertEquals(v, i)
+            id1 = self.mvs.create_nodevalue(i)
+            assert id1 != None
+
+            v = self.mvs.read_value(id1)
+            assert v == i
 
     def test_read_value_boolean(self):
-        id1, r1 = self.mvs.create_nodevalue(True)
-        id2, r2 = self.mvs.create_nodevalue(False)
-        self.assertEquals(r1, status.SUCCESS)
-        self.assertEquals(r2, status.SUCCESS)
+        id1 = self.mvs.create_nodevalue(True)
+        id2 = self.mvs.create_nodevalue(False)
+        assert id1 != None
+        assert id2 != None
 
-        v1, r1 = self.mvs.read_value(id1)
-        v2, r2 = self.mvs.read_value(id2)
-        self.assertEquals(r1, status.SUCCESS)
-        self.assertEquals(r2, status.SUCCESS)
-        self.assertEquals(v1, True)
-        self.assertEquals(v2, False)
+        v1 = self.mvs.read_value(id1)
+        v2 = self.mvs.read_value(id2)
+        assert v1 == True
+        assert v2 == False
 
     def test_read_nodevalue_boolean_same(self):
-        id1, r1 = self.mvs.create_nodevalue(True)
-        id2, r2 = self.mvs.create_nodevalue(True)
-        self.assertEquals(r1, status.SUCCESS)
-        self.assertEquals(r2, status.SUCCESS)
+        id1 = self.mvs.create_nodevalue(True)
+        id2 = self.mvs.create_nodevalue(True)
+        assert id1 != None
+        assert id2 != None
 
-        v1, r1 = self.mvs.read_value(id1)
-        v2, r2 = self.mvs.read_value(id2)
-        self.assertEquals(r1, status.SUCCESS)
-        self.assertEquals(r2, status.SUCCESS)
-        self.assertEquals(v1, True)
-        self.assertEquals(v2, True)
+        v1 = self.mvs.read_value(id1)
+        v2 = self.mvs.read_value(id2)
+        assert v1 == True
+        assert v2 == True
 
     def test_read_value_no_exist(self):
-        v1, r1 = self.mvs.read_value(100000)
-        self.assertEquals(r1, status.FAIL_RV_UNKNOWN)
-        self.assertEquals(v1, None)
+        v1 = self.mvs.read_value(100000)
+        assert v1 == None
 
     def test_read_value_no_value(self):
-        id1, r1 = self.mvs.create_node()
-        self.assertEquals(r1, status.SUCCESS)
+        id1 = self.mvs.create_node()
+        assert id1 != None
 
-        v1, r1 = self.mvs.read_value(id1)
-        self.assertEquals(r1, status.FAIL_RV_NO_VALUE)
-        self.assertEquals(v1, None)
+        v1 = self.mvs.read_value(id1)
+        assert v1 == None