First few changes to make Modelverse without primitive type hierarchy

bootstrap/bootstrap.py

@@ -21,8 +21,6 @@ primitives = {  "integer_addition": ["Integer", "Integer", "Integer"],
                 "integer_gte": ["Boolean", "Integer", "Integer"],
                 "integer_lt": ["Boolean", "Integer", "Integer"],
                 "integer_lte": ["Boolean", "Integer", "Integer"],
-                "integer_eq": ["Boolean", "Integer", "Integer"],
-                "integer_neq": ["Boolean", "Integer", "Integer"],
                 "integer_neg": ["Integer", "Integer"],
                 "float_addition": ["Float", "Float", "Float"],
                 "float_subtraction": ["Float", "Float", "Float"],
@@ -32,26 +30,18 @@ primitives = {  "integer_addition": ["Integer", "Integer", "Integer"],
                 "float_gte": ["Boolean", "Float", "Float"],
                 "float_lt": ["Boolean", "Float", "Float"],
                 "float_lte": ["Boolean", "Float", "Float"],
-                "float_eq": ["Boolean", "Float", "Float"],
-                "float_neq": ["Boolean", "Float", "Float"],
                 "float_neg": ["Float", "Float"],
                 "bool_and": ["Boolean", "Boolean", "Boolean"],
                 "bool_or": ["Boolean", "Boolean", "Boolean"],
                 "bool_not": ["Boolean", "Boolean"],
-                "bool_eq": ["Boolean", "Boolean", "Boolean"],
-                "bool_neq": ["Boolean", "Boolean", "Boolean"],
                 "string_join": ["String", "String", "String"],
                 "string_get": ["String", "String", "Integer"],
                 "string_substr": ["String", "String", "Integer", "Integer"],
                 "string_len": ["Integer", "String"],
                 "string_split": ["Element", "String", "String"],
                 "string_startswith": ["Boolean", "String", "String"],
-                "string_eq": ["Boolean", "String", "String"],
-                "string_neq": ["Boolean", "String", "String"],
-                "action_eq": ["Boolean", "Action", "Action"],
-                "action_neq": ["Boolean", "Action", "Action"],
-                "type_eq": ["Boolean", "Type", "Type"],
-                "type_neq": ["Boolean", "Type", "Type"],
+                "value_eq":  ["Boolean", "Element", "Element"],
+                "value_neq": ["Boolean", "Element", "Element"],
                 "cast_i2f": ["Float", "Integer"],
                 "cast_i2s": ["String", "Integer"],
                 "cast_i2b": ["Boolean", "Integer"],
@@ -65,7 +55,6 @@ primitives = {  "integer_addition": ["Integer", "Integer", "Integer"],
                 "cast_b2f": ["Float", "Boolean"],
                 "cast_b2s": ["String", "Boolean"],
                 "cast_e2s": ["String", "Element"],
-                "cast_t2s": ["String", "Type"],
                 "cast_a2s": ["String", "Action"],
                 "cast_v2s": ["String", "Element"],
                 "cast_id2s": ["String", "Element"],
@@ -89,7 +78,11 @@ primitives = {  "integer_addition": ["Integer", "Integer", "Integer"],
                 "set_remove_node": ["Element", "Element", "Element"],
                 "set_in": ["Boolean", "Element", "Element"],
                 "set_in_node": ["Boolean", "Element", "Element"],
-                "typeof": ["Type", "Element"],
+                "is_physical_int": ["Boolean", "Element"],
+                "is_physical_bool": ["Boolean", "Element"],
+                "is_physical_string": ["Boolean", "Element"],
+                "is_physical_action": ["Boolean", "Element"],
+                "is_physical_float": ["Boolean", "Element"],
                 "create_node": ["Element"],
                 "create_edge": ["Element", "Element", "Element"],
                 "create_value": ["Element", "Element"],
@@ -116,7 +109,7 @@ Element function dict_read(a: Element, b: Element) = ?primitives/dict_read
 Element function create_node() = ?primitives/create_node
 Element function create_value(a: Element) = ?primitives/create_value
 Element function dict_add(a: Element, b: Element, c: Element) = ?primitives/dict_add
-Boolean function string_eq(a: String, b: String) = ?primitives/string_eq
+Boolean function value_eq(a: String, b: String) = ?primitives/value_eq
 Boolean function delete_element(a: Element) = ?primitives/delete_element
 Boolean function bool_not(a: Boolean) = ?primitives/bool_not
 Boolean function dict_in(a: Element, b: Element) = ?primitives/dict_in
@@ -132,7 +125,7 @@ Void function __main():
 \t
 \twhile (True):
 \t\tusername = input()
-\t\tif (string_eq(username, "__delete")):
+\t\tif (value_eq(username, "__delete")):
 \t\t\tuser_root = dict_read(read_root(), input())
 \t\t\tdelete_element(user_root)
 \t\telse:
@@ -173,12 +166,12 @@ Void function __main():
 \tInteger interface
 \twhile (True):
 \t\tinterface = input()
-\t\tif (integer_eq(interface, 0)):
+\t\tif (interface == 0):
 \t\t\tlog("DO deserialize")
 \t\t\texec(deserialize(input()))
-\t\telif (integer_eq(interface, 1)):
+\t\telif (interface == 1):
 \t\t\texec(construct_unknown())
-\t\telif (integer_eq(interface, 3)):
+\t\telif (interface == 3):
 \t\t\tcompilation_manager()
 \t\telse:
 \t\t\tlog("Unsupported interface!")
@@ -219,10 +212,10 @@ try:
 
             # Define all primitive functions
             for function, parameters in primitives.iteritems():
-                if parameters[0] == "Element":
-                    f.write("Node _type_%s()\n" % function)
-                else:
-                    f.write("Node _type_%s(%s)\n" % (function, parameters[0]))
+                #if parameters[0] == "Element":
+                #    f.write("Node _type_%s()\n" % function)
+                #else:
+                #    f.write("Node _type_%s(%s)\n" % (function, parameters[0]))
                     
                 f.write("Node _func_signature_%s()\n" % function)
                 f.write("Node _func_params_%s()\n" % function)
@@ -239,17 +232,17 @@ try:
                 f.write("Edge _signature_params_%s(_func_signature_%s, _func_params_%s)\n" % (function, function, function))
                 f.write("Edge _signature_params_str_%s(_signature_params_%s, _params_%s)\n" % (function, function, function))
 
-                f.write('Node _type_str_%s("type")\n' % function)
-                f.write("Edge _signature_type_%s(_func_signature_%s, _type_%s)\n" % (function, function, function))
-                f.write("Edge _signature_type_str_%s(_signature_type_%s, _type_str_%s)\n" % (function, function, function))
+                #f.write('Node _type_str_%s("type")\n' % function)
+                #f.write("Edge _signature_type_%s(_func_signature_%s, _type_%s)\n" % (function, function, function))
+                #f.write("Edge _signature_type_str_%s(_signature_type_%s, _type_str_%s)\n" % (function, function, function))
 
                 parameter_names = "abcdefghijklmnopqrstuvwxyz"
                 for number, param in enumerate(parameters[1:]):
                     param_encoding = "%s_%s" % (function, parameter_names[number])
-                    if param == "Element":
-                        f.write("Node _type_%s()\n" % param_encoding)
-                    else:
-                        f.write("Node _type_%s(%s)\n" % (param_encoding, param))
+                    #if param == "Element":
+                    #    f.write("Node _type_%s()\n" % param_encoding)
+                    #else:
+                    #    f.write("Node _type_%s(%s)\n" % (param_encoding, param))
 
                     f.write("Node _func_params_%s()\n" % (param_encoding))
                     f.write('Node _name_%s("%s")\n' % (param_encoding, parameter_names[number]))
@@ -258,9 +251,9 @@ try:
                     f.write('Node _name_str_%s("name")\n' % param_encoding)
                     f.write("Edge _param_name_%s(_func_params_%s, _name_%s)\n" % (param_encoding, param_encoding, param_encoding))
                     f.write("Edge _param_name_str_%s(_param_name_%s, _name_str_%s)\n" % (param_encoding, param_encoding, param_encoding))
-                    f.write('Node _type_str_%s("type")\n' % param_encoding)
-                    f.write("Edge _param_type_%s(_func_params_%s, _type_%s)\n" % (param_encoding, param_encoding, param_encoding))
-                    f.write("Edge _param_type_str_%s(_param_type_%s, _type_str_%s)\n" % (param_encoding, param_encoding, param_encoding))
+                    #f.write('Node _type_str_%s("type")\n' % param_encoding)
+                    #f.write("Edge _param_type_%s(_func_params_%s, _type_%s)\n" % (param_encoding, param_encoding, param_encoding))
+                    #f.write("Edge _param_type_str_%s(_param_type_%s, _type_str_%s)\n" % (param_encoding, param_encoding, param_encoding))
 
             # Create the initial user
             f.write("Node user_root()\n")

bootstrap/conformance_scd.alc

@@ -125,11 +125,6 @@ String function conformance_scd(model : Element):
 		if (bool_not(set_in_node(metamodels, dict_read_node(typing, work_node)))):
 			return "Type of element not in specified metamodel: " + getName(model, work_node)
 
-		// Basic check: type of the value agrees with the actual type
-		// this is always checked, as it falls back to a sane default for non-values
-		if (bool_not(type_eq(dict_read_node(typing, work_node), typeof(work_node)))):
-			return "Primitive type does not agree with actual type: " + getName(model, work_node)
-
 		// For edges only: check whether the source is typed according to the metamodel
 		if (is_edge(work_node)):
 			model_src = read_edge_src(work_node)

bootstrap/primitives.alc

@@ -1,10 +1,8 @@
-Boolean function action_eq(a: Action, b: Action) = ?primitives/action_eq
-Boolean function action_neq(a: Action, b: Action) = ?primitives/action_neq
+Boolean function value_eq(a: Element, b: Element) = ?primitives/value_eq
+Boolean function value_neq(a: Element, b: Element) = ?primitives/value_neq
 Boolean function bool_and(a: Boolean, b: Boolean) = ?primitives/bool_and
 Boolean function bool_or(a: Boolean, b: Boolean) = ?primitives/bool_or
 Boolean function bool_not(a: Boolean) = ?primitives/bool_not
-Boolean function bool_eq(a: Boolean, b: Boolean) = ?primitives/bool_eq
-Boolean function bool_neq(a: Boolean, b: Boolean) = ?primitives/bool_neq
 Element function create_node() = ?primitives/create_node
 Element function create_edge(a: Element, b: Element) = ?primitives/create_edge
 Element function create_value(a: Element) = ?primitives/create_value
@@ -52,8 +50,6 @@ Boolean function float_gt(a: Float, b: Float) = ?primitives/float_gt
 Boolean function float_gte(a: Float, b: Float) = ?primitives/float_gte
 Boolean function float_lt(a: Float, b: Float) = ?primitives/float_lt
 Boolean function float_lte(a: Float, b: Float) = ?primitives/float_lte
-Boolean function float_eq(a: Float, b: Float) = ?primitives/float_eq
-Boolean function float_neq(a: Float, b: Float) = ?primitives/float_neq
 Boolean function float_neg(a: Float) = ?primitives/float_neg
 Integer function integer_addition(a: Integer, b: Integer) = ?primitives/integer_addition
 Integer function integer_subtraction(a: Integer, b: Integer) = ?primitives/integer_subtraction
@@ -63,8 +59,6 @@ Boolean function integer_gt(a: Integer, b: Integer) = ?primitives/integer_gt
 Boolean function integer_gte(a: Integer, b: Integer) = ?primitives/integer_gte
 Boolean function integer_lt(a: Integer, b: Integer) = ?primitives/integer_lt
 Boolean function integer_lte(a: Integer, b: Integer) = ?primitives/integer_lte
-Boolean function integer_eq(a: Integer, b: Integer) = ?primitives/integer_eq
-Boolean function integer_neq(a: Integer, b: Integer) = ?primitives/integer_neq
 Boolean function integer_neg(a: Integer) = ?primitives/integer_neg
 Element function list_read(a: Element, b: Integer) = ?primitives/list_read
 Element function list_append(a: Element, b: Element) = ?primitives/list_append
@@ -81,16 +75,16 @@ String function string_join(a: String, b: String) = ?primitives/string_join
 String function string_get(a: String, b: Integer) = ?primitives/string_get
 String function string_substr(a: String, b: Integer, c: Integer) = ?primitives/string_substr
 Integer function string_len(a: String) = ?primitives/string_len
-Boolean function string_eq(a: String, b: String) = ?primitives/string_eq
-Boolean function string_neq(a: String, b: String) = ?primitives/string_neq
 Element function string_split(a: String, b: String) = ?primitives/string_split
 Boolean function string_startswith(a: String, b: String) = ?primitives/string_startswith
-Boolean function type_eq(a: Type, b: Type) = ?primitives/type_eq
-Boolean function type_neq(a: Type, b: Type) = ?primitives/type_neq
-Type function typeof(a: Element) = ?primitives/typeof
 Element function deserialize(a: String) = ?primitives/deserialize
 Element function log(a: String) = ?primitives/log
 Element function read_root() = ?primitives/read_root
+Boolean function is_physical_int(a: Element) = ?primitives/is_physical_int
+Boolean function is_physical_float(a: Element) = ?primitives/is_physical_float
+Boolean function is_physical_string(a: Element) = ?primitives/is_physical_string
+Boolean function is_physical_boolean(a: Element) = ?primitives/is_physical_boolean
+Boolean function is_physical_action(a: Element) = ?primitives/is_physical_action
 
 Element function exec(first_instr : Element):
 	// This does very ugly things, so beware!

interface/HUTN/hutn_compiler/semantics_visitor.py

@@ -294,10 +294,15 @@ class SemanticsVisitor(Visitor):
         if str(operand_type) == "String":
             if operator.head == "PLUS":
                 return "string_join"
-        call_name = "{}_{}".format(SemanticsVisitor.types[str(operand_type)],
-                                   SemanticsVisitor.binary_ops[operator.head])
+        elif operator.head == "EQ":
+            return "value_eq"
+        elif operator.head == "NEQ":
+            return "value_neq"
+        else:
+            call_name = "{}_{}".format(SemanticsVisitor.types[str(operand_type)],
+                                       SemanticsVisitor.binary_ops[operator.head])
 
-        return call_name
+            return call_name
 
     @staticmethod
     def call_name_unary(operand_type, operator):

interface/HUTN/includes/primitives.alh

@@ -1,10 +1,8 @@
-Boolean function action_eq(a: Action, b: Action)
-Boolean function action_neq(a: Action, b: Action)
+Boolean function value_eq(a: Element, b: Element)
+Boolean function value_neq(a: Element, b: Element) 
 Boolean function bool_and(a: Boolean, b: Boolean)
 Boolean function bool_or(a: Boolean, b: Boolean)
 Boolean function bool_not(a: Boolean)
-Boolean function bool_eq(a: Boolean, b: Boolean)
-Boolean function bool_neq(a: Boolean, b: Boolean)
 Element function create_node()
 Element function create_edge(a: Element, b: Element)
 Element function create_value(a: Element) 
@@ -52,8 +50,6 @@ Boolean function float_gt(a: Float, b: Float)
 Boolean function float_gte(a: Float, b: Float) 
 Boolean function float_lt(a: Float, b: Float) 
 Boolean function float_lte(a: Float, b: Float) 
-Boolean function float_eq(a: Float, b: Float) 
-Boolean function float_neq(a: Float, b: Float) 
 Boolean function float_neg(a: Float)
 Integer function integer_addition(a: Integer, b: Integer)
 Integer function integer_subtraction(a: Integer, b: Integer) 
@@ -63,8 +59,6 @@ Boolean function integer_gt(a: Integer, b: Integer)
 Boolean function integer_gte(a: Integer, b: Integer) 
 Boolean function integer_lt(a: Integer, b: Integer) 
 Boolean function integer_lte(a: Integer, b: Integer) 
-Boolean function integer_eq(a: Integer, b: Integer) 
-Boolean function integer_neq(a: Integer, b: Integer) 
 Boolean function integer_neg(a: Integer)
 Element function list_read(a: Element, b: Integer)
 Element function list_append(a: Element, b: Element) 
@@ -81,16 +75,16 @@ String function string_join(a: String, b: String)
 String function string_get(a: String, b: Integer) 
 String function string_substr(a: String, b: Integer, c: Integer) 
 Integer function string_len(a: String) 
-Boolean function string_eq(a: String, b: String) 
-Boolean function string_neq(a: String, b: String) 
 Element function string_split(a: String, b: String) 
 Boolean function string_startswith(a: String, b: String) 
-Boolean function type_eq(a: Type, b: Type) 
-Boolean function type_neq(a: Type, b: Type) 
-Type function typeof(a: Element) 
 Element function deserialize(a: String) 
 String function log(a: String)
 Element function read_root()
 Element function exec(a : Element)
 Element function input()
 Element function output(a : Element)
+Boolean function is_physical_int(a : Element)
+Boolean function is_physical_float(a : Element)
+Boolean function is_physical_string(a : Element)
+Boolean function is_physical_action(a : Element)
+Boolean function is_physical_boolean(a : Element)

kernel/modelverse_kernel/primitives.py

@@ -43,16 +43,6 @@ def integer_lte(a, b, **remainder):
     result = yield [("CNV", [a_value <= b_value])]
     raise PrimitiveFinished(result)
 
-def integer_eq(a, b, **remainder):
-    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value == b_value])]
-    raise PrimitiveFinished(result)
-
-def integer_neq(a, b, **remainder):
-    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value != b_value])]
-    raise PrimitiveFinished(result)
-
 def integer_neg(a, **remainder):
     a_value =           yield [("RV", [a])]
     result = yield [("CNV", [-a_value])]
@@ -73,16 +63,6 @@ def bool_not(a, **remainder):
     result = yield [("CNV", [not a_value])]
     raise PrimitiveFinished(result)
 
-def bool_eq(a, b, **remainder):
-    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value == b_value])]
-    raise PrimitiveFinished(result)
-
-def bool_neq(a, b, **remainder):
-    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value != b_value])]
-    raise PrimitiveFinished(result)
-
 def float_subtraction(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
     result = yield [("CNV", [a_value - b_value])]
@@ -123,16 +103,6 @@ def float_lte(a, b, **remainder):
     result = yield [("CNV", [a_value <= b_value])]
     raise PrimitiveFinished(result)
 
-def float_eq(a, b, **remainder):
-    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value == b_value])]
-    raise PrimitiveFinished(result)
-
-def float_neq(a, b, **remainder):
-    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value != b_value])]
-    raise PrimitiveFinished(result)
-
 def float_neg(a, **remainder):
     a_value =           yield [("RV", [a])]
     result = yield [("CNV", [-a_value])]
@@ -166,38 +136,18 @@ def string_len(a, **remainder):
     result = yield [("CNV", [len(a_value)])]
     raise PrimitiveFinished(result)
 
-def string_eq(a, b, **remainder):
-    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value == b_value])]
-    raise PrimitiveFinished(result)
-
-def string_neq(a, b, **remainder):
-    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value != b_value])]
-    raise PrimitiveFinished(result)
-
 def string_startswith(a, b, **remainder):
     #TODO implement in AL
     a_value, b_value = yield [("RV", [a]), ("RV", [b])]
     result = yield [("CNV", [a_value.startswith(b_value)])]
     raise PrimitiveFinished(result)
 
-def action_eq(a, b, **remainder):
+def value_eq(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
     result = yield [("CNV", [a_value == b_value])]
     raise PrimitiveFinished(result)
 
-def action_neq(a, b, **remainder):
-    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value != b_value])]
-    raise PrimitiveFinished(result)
-
-def type_eq(a, b, **remainder):
-    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value == b_value])]
-    raise PrimitiveFinished(result)
-
-def type_neq(a, b, **remainder):
+def value_neq(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
     result = yield [("CNV", [a_value != b_value])]
     raise PrimitiveFinished(result)
@@ -215,11 +165,6 @@ def cast_a2s(a, **remainder):
     result = yield [("CNV", [str(a_value["value"])])]
     raise PrimitiveFinished(result)
 
-def cast_t2s(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [str(a_value["value"])])]
-    raise PrimitiveFinished(result)
-
 def cast_i2f(a, **remainder):
     a_value = yield [("RV", [a])]
     result = yield [("CNV", [float(a_value)])]
@@ -388,25 +333,29 @@ def dict_keys(a, **remainder):
     yield [("CE", [result, v]) for v in keys]
     raise PrimitiveFinished(result)
 
-def typeof(a, **remainder):
+def is_physical_int(a, **remainder):
     t = yield [("RV", [a])]
-    if isinstance(t, bool):
-        r = "Boolean"
-    elif isinstance(t, int) or isinstance(t, long):
-        r = "Integer"
-    elif isinstance(t, str) or isinstance(t, unicode):
-        r = "String"
-    elif isinstance(t, float):
-        r = "Float"
-    elif isinstance(t, dict):
-        if t["value"] in ["if", "while", "assign", "call", "break", "continue", "return","resolve","access", "constant"]:
-            r = "Action"
-        elif t["value"] in ["Integer", "Float", "String", "Boolean", "Action", "Type"]:
-            r = "Type"
-    else:
-        result = yield [("CN", [])]
-        raise PrimitiveFinished(result)
-    result = yield [("CNV", [{"value": r}])]
+    result = yield [("CNV", [isinstance(t, int) or isinstance(t, long)])]
+    raise PrimitiveFinished(result)
+
+def is_physical_string(a, **remainder):
+    t = yield [("RV", [a])]
+    result = yield [("CNV", [isinstance(t, str) or isinstance(t, unicode)])]
+    raise PrimitiveFinished(result)
+
+def is_physical_float(a, **remainder):
+    t = yield [("RV", [a])]
+    result = yield [("CNV", [isinstance(t, float)])]
+    raise PrimitiveFinished(result)
+
+def is_physical_bool(a, **remainder):
+    t = yield [("RV", [a])]
+    result = yield [("CNV", [isinstance(t, bool)])]
+    raise PrimitiveFinished(result)
+
+def is_physical_action(a, **remainder):
+    t = yield [("RV", [a])]
+    result = yield [("CNV", [isinstance(t, dict) and t["value"] in ["if", "while", "assign", "call", "break", "continue", "return", "resolve", "access", "constant", "global", "declare"]])]
     raise PrimitiveFinished(result)
 
 def create_node(**remainder):
@@ -526,7 +475,7 @@ def deserialize(a, root, **remainder):
     print("DESERIALIZE")
     value = yield [("RV", [a])]
     id_mappings = {}
-    complex_primitives = frozenset(["if", "while", "assign", "call", "break", "continue", "return","resolve","access", "constant", "input", "output", "declare", "global", "Integer", "Float", "String", "Boolean", "Action", "Type"])
+    complex_primitives = frozenset(["if", "while", "assign", "call", "break", "continue", "return","resolve","access", "constant", "input", "output", "declare", "global"])
     for l in value.split("\n"):
         try:
             graph_type, constructor = l.split(None, 1)

kernel/test/primitives/test_action.py

@@ -26,22 +26,22 @@ class TestAction(unittest.TestCase):
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
 
     def test_eq_true(self):
-        self.helper_primitives_2_params("action_eq", {"value": "while"}, {"value": "while"}, True)
+        self.helper_primitives_2_params("value_eq", {"value": "while"}, {"value": "while"}, True)
 
     def test_eq_false(self):
-        self.helper_primitives_2_params("action_eq", {"value": "while"}, {"value": "call"}, False)
+        self.helper_primitives_2_params("value_eq", {"value": "while"}, {"value": "call"}, False)
 
     def test_eq_diff(self):
-        self.helper_primitives_2_params("action_eq", {"value": "while"}, 10, False)
+        self.helper_primitives_2_params("value_eq", {"value": "while"}, 10, False)
 
     def test_neq_true(self):
-        self.helper_primitives_2_params("action_neq", {"value": "while"}, {"value": "while"}, False)
+        self.helper_primitives_2_params("value_neq", {"value": "while"}, {"value": "while"}, False)
 
     def test_neq_false(self):
-        self.helper_primitives_2_params("action_neq", {"value": "while"}, {"value": "call"}, True)
+        self.helper_primitives_2_params("value_neq", {"value": "while"}, {"value": "call"}, True)
 
     def test_neq_diff(self):
-        self.helper_primitives_2_params("action_neq", {"value": "while"}, 10, True)
+        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]

kernel/test/primitives/test_bool.py

@@ -56,28 +56,28 @@ class TestBool(unittest.TestCase):
         self.helper_primitives_1_params("bool_not", False, True)
 
     def test_eq_T_T(self):
-        self.helper_primitives_2_params("bool_eq", True, True, True)
+        self.helper_primitives_2_params("value_eq", True, True, True)
 
     def test_eq_T_F(self):
-        self.helper_primitives_2_params("bool_eq", True, False, False)
+        self.helper_primitives_2_params("value_eq", True, False, False)
 
     def test_eq_F_T(self):
-        self.helper_primitives_2_params("bool_eq", False, True, False)
+        self.helper_primitives_2_params("value_eq", False, True, False)
 
     def test_eq_F_F(self):
-        self.helper_primitives_2_params("bool_eq", False, False, True)
+        self.helper_primitives_2_params("value_eq", False, False, True)
 
     def test_neq_T_T(self):
-        self.helper_primitives_2_params("bool_neq", True, True, False)
+        self.helper_primitives_2_params("value_neq", True, True, False)
 
     def test_neq_T_F(self):
-        self.helper_primitives_2_params("bool_neq", True, False, True)
+        self.helper_primitives_2_params("value_neq", True, False, True)
 
     def test_neq_F_T(self):
-        self.helper_primitives_2_params("bool_neq", False, True, True)
+        self.helper_primitives_2_params("value_neq", False, True, True)
 
     def test_neq_F_F(self):
-        self.helper_primitives_2_params("bool_neq", False, False, False)
+        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]

kernel/test/primitives/test_cast.py

@@ -112,12 +112,6 @@ class TestCast(unittest.TestCase):
     def test_cast_v2s_action(self):
         self.helper_primitives_1_params("cast_v2s", {"value": "call"}, "call")
 
-    def test_cast_v2s_typetype(self):
-        self.helper_primitives_1_params("cast_v2s", {"value": "Type"}, "Type")
-
-    def test_cast_v2s_type(self):
-        self.helper_primitives_1_params("cast_v2s", {"value": "Integer"}, "Integer")
-
     def test_cast_id2s_node(self):
         n = self.mvs.execute("CN", [])[0]
         self.helper_primitives_1_params("cast_id2s", n, str(n), t=True)

kernel/test/primitives/test_float.py

@@ -74,16 +74,16 @@ class TestInteger(unittest.TestCase):
         self.helper_primitives_2_params("float_lte", 5.8, 2.4, False)
 
     def test_eq_diff(self):
-        self.helper_primitives_2_params("float_eq", 2.4, 5.8, False)
+        self.helper_primitives_2_params("value_eq", 2.4, 5.8, False)
 
     def test_eq_eq(self):
-        self.helper_primitives_2_params("float_eq", 2.4, 2.4, True)
+        self.helper_primitives_2_params("value_eq", 2.4, 2.4, True)
 
     def test_neq_diff(self):
-        self.helper_primitives_2_params("float_neq", 2.4, 5.8, True)
+        self.helper_primitives_2_params("value_neq", 2.4, 5.8, True)
 
     def test_neq_eq(self):
-        self.helper_primitives_2_params("float_neq", 2.4, 2.4, False)
+        self.helper_primitives_2_params("value_neq", 2.4, 2.4, False)
 
     def test_neg_pos(self):
         self.helper_primitives_1_params("float_neg", 5.8, -5.8)

kernel/test/primitives/test_integer.py

@@ -74,16 +74,16 @@ class TestInteger(unittest.TestCase):
         self.helper_primitives_2_params("integer_lte", 5, 2, False)
 
     def test_eq_diff(self):
-        self.helper_primitives_2_params("integer_eq", 2, 5, False)
+        self.helper_primitives_2_params("value_eq", 2, 5, False)
 
     def test_eq_eq(self):
-        self.helper_primitives_2_params("integer_eq", 2, 2, True)
+        self.helper_primitives_2_params("value_eq", 2, 2, True)
 
     def test_neq_diff(self):
-        self.helper_primitives_2_params("integer_neq", 2, 5, True)
+        self.helper_primitives_2_params("value_neq", 2, 5, True)
 
     def test_neq_eq(self):
-        self.helper_primitives_2_params("integer_neq", 2, 2, False)
+        self.helper_primitives_2_params("value_neq", 2, 2, False)
 
     def test_neg_pos(self):
         self.helper_primitives_1_params("integer_neg", 5, -5)

kernel/test/primitives/test_string.py

@@ -26,34 +26,34 @@ class TestString(unittest.TestCase):
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
 
     def test_eq(self):
-        self.helper_primitives_2_params("string_eq", "abc", "abc", True)
+        self.helper_primitives_2_params("value_eq", "abc", "abc", True)
 
     def test_eq_startswith(self):
-        self.helper_primitives_2_params("string_eq", "abc", "abcdef", False)
+        self.helper_primitives_2_params("value_eq", "abc", "abcdef", False)
 
     def test_eq_samelength(self):
-        self.helper_primitives_2_params("string_eq", "abc", "def", False)
+        self.helper_primitives_2_params("value_eq", "abc", "def", False)
 
     def test_eq_diff(self):
-        self.helper_primitives_2_params("string_eq", "abc", "defghij", False)
+        self.helper_primitives_2_params("value_eq", "abc", "defghij", False)
 
     def test_eq_empty(self):
-        self.helper_primitives_2_params("string_eq", "", "", True)
+        self.helper_primitives_2_params("value_eq", "", "", True)
 
     def test_neq(self):
-        self.helper_primitives_2_params("string_neq", "abc", "abc", False)
+        self.helper_primitives_2_params("value_neq", "abc", "abc", False)
 
     def test_neq_startswith(self):
-        self.helper_primitives_2_params("string_neq", "abc", "abcdef", True)
+        self.helper_primitives_2_params("value_neq", "abc", "abcdef", True)
 
     def test_neq_samelength(self):
-        self.helper_primitives_2_params("string_neq", "abc", "def", True)
+        self.helper_primitives_2_params("value_neq", "abc", "def", True)
 
     def test_neq_diff(self):
-        self.helper_primitives_2_params("string_neq", "abc", "defghij", True)
+        self.helper_primitives_2_params("value_neq", "abc", "defghij", True)
 
     def test_neq_empty(self):
-        self.helper_primitives_2_params("string_neq", "", "", False)
+        self.helper_primitives_2_params("value_neq", "", "", False)
 
     def test_join(self):
         self.helper_primitives_2_params("string_join", "abc", "def", "abcdef")

kernel/test/primitives/test_type.py

@@ -1,191 +0,0 @@
-import unittest
-from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces
-
-class TestType(unittest.TestCase):
-    def setUp(self):
-        self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
-        self.mvk = ModelverseKernel(self.root)
-
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_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.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
-
-        execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
-        self.primitives = read_primitive_interfaces(self.root, self.mvs)
-
-    def test_eq_true(self):
-        self.helper_primitives_2_params("type_eq", {"value": "Integer"}, {"value": "Integer"}, True)
-
-    def test_eq_false(self):
-        self.helper_primitives_2_params("type_eq", {"value": "Integer"}, {"value": "Float"}, False)
-
-    def test_eq_diff(self):
-        self.helper_primitives_2_params("type_eq", {"value": "Integer"}, 10, False)
-
-    def test_neq_true(self):
-        self.helper_primitives_2_params("type_neq", {"value": "Integer"}, {"value": "Integer"}, False)
-
-    def test_neq_false(self):
-        self.helper_primitives_2_params("type_neq", {"value": "Integer"}, {"value": "Float"}, True)
-
-    def test_neq_diff(self):
-        self.helper_primitives_2_params("type_neq", {"value": "Integer"}, 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.mvs.execute("CD", [self.user_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        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])
-        self.mvs.execute("CD", [self.inst, "params", self.actual_arg_a])
-        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_first])
-        self.mvs.execute("CD", [self.actual_arg_b, "value", self.const_second])
-        self.mvs.execute("CD", [self.actual_arg_a, "name", self.value_a])
-        self.mvs.execute("CD", [self.actual_arg_b, "name", self.value_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_c, "node", self.value_c])
-        self.mvs.execute("CD", [self.const_first, "node", self.value_first])
-        self.mvs.execute("CD", [self.const_second, "node", self.value_second])
-
-        ### Execute rules
-        self.assertEquals(get_inst(self.root, self.mvs), "call")
-        self.assertEquals(get_phase(self.root, self.mvs), "init")
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "init")
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "call")
-        self.assertEquals(get_phase_ref(self.root, self.mvs), self.actual_arg_a)
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "init")
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertEquals(get_returnvalue(self.root, self.mvs), a)
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "call")
-        self.assertEquals(get_phase_ref(self.root, self.mvs), self.actual_arg_b)
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "init")
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertEquals(get_returnvalue(self.root, self.mvs), b)
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "call")
-        self.assertEquals(get_phase(self.root, self.mvs), "call")
-        execute_until_finished(self.mvk, self.mvs)
-
-        # Body points to empty instruction, as it is a primitive
-        self.assertEquals(get_phase(self.root, self.mvs), "init")
-        execute_until_finished(self.mvk, self.mvs)
-
-        # This will have triggered the primitive, so now we are back where we left off
-        # Just check whether or not the correct value is in the returnvalue to be used
-        self.assertEquals(get_inst(self.root, self.mvs), "call")
-        self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertEquals(get_returnvalue(self.root, self.mvs), result)
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "init")
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        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.mvs.execute("CD", [self.user_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        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])
-        self.mvs.execute("CD", [self.inst, "params", self.actual_arg_a])
-        self.mvs.execute("CD", [self.inst, "last_param", self.actual_arg_a])
-        self.mvs.execute("CD", [self.actual_arg_a, "value", self.const_first])
-        self.mvs.execute("CD", [self.actual_arg_a, "name", self.value_a])
-        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])
-        self.mvs.execute("CD", [self.const_first, "node", self.value_first])
-
-        ### Execute rules
-        self.assertEquals(get_inst(self.root, self.mvs), "call")
-        self.assertEquals(get_phase(self.root, self.mvs), "init")
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "init")
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "call")
-        self.assertEquals(get_phase_ref(self.root, self.mvs), self.actual_arg_a)
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "init")
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "finish")

kernel/test/primitives/test_typeof.py

@@ -1,125 +0,0 @@
-import unittest
-from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
-
-class TestTypeof(unittest.TestCase):
-    def setUp(self):
-        self.mvs = MvSWrapper()
-        self.root = self.mvs.execute("RR", [])[0]
-        self.mvk = ModelverseKernel(self.root)
-
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_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.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
-
-        execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
-        self.primitives = read_primitive_interfaces(self.root, self.mvs)
-
-    def test_typeof_node(self):
-        self.helper_primitives_1_params("typeof", None, None)
-
-    def test_typeof_int(self):
-        self.helper_primitives_1_params("typeof", 5, "Integer")
-
-    def test_typeof_float(self):
-        self.helper_primitives_1_params("typeof", 5.0, "Float")
-
-    def test_typeof_action(self):
-        self.helper_primitives_1_params("typeof", {"value": "while"}, "Action")
-
-    def test_typeof_type(self):
-        self.helper_primitives_1_params("typeof", {"value": "Integer"}, "Type")
-
-    def test_typeof_string(self):
-        self.helper_primitives_1_params("typeof", "abc", "String")
-
-    def test_typeof_typetype(self):
-        self.helper_primitives_1_params("typeof", {"value": "Type"}, "Type")
-
-    def test_typeof_bool(self):
-        self.helper_primitives_1_params("typeof", False, "Boolean")
-
-    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]
-        if a is not None:
-            self.value_first = self.mvs.execute("CNV", [a])[0]
-        else:
-            self.value_first = self.mvs.execute("CN", [])[0]
-
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
-        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        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])
-        self.mvs.execute("CD", [self.inst, "params", self.actual_arg_a])
-        self.mvs.execute("CD", [self.inst, "last_param", self.actual_arg_a])
-        self.mvs.execute("CD", [self.actual_arg_a, "value", self.const_first])
-        self.mvs.execute("CD", [self.actual_arg_a, "name", self.value_a])
-        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])
-        self.mvs.execute("CD", [self.const_first, "node", self.value_first])
-
-        ### Execute rules
-        self.assertEquals(get_inst(self.root, self.mvs), "call")
-        self.assertEquals(get_phase(self.root, self.mvs), "init")
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "init")
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "call")
-        self.assertEquals(get_phase_ref(self.root, self.mvs), self.actual_arg_a)
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "init")
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "constant")
-        self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertEquals(get_returnvalue_ref(self.root, self.mvs), self.value_first)
-        execute_until_finished(self.mvk, self.mvs)
-
-        self.assertEquals(get_inst(self.root, self.mvs), "call")
-        self.assertEquals(get_phase(self.root, self.mvs), "call")
-        execute_until_finished(self.mvk, self.mvs)
-
-        # Body points to empty instruction, as it is a primitive
-        self.assertEquals(get_phase(self.root, self.mvs), "init")
-        execute_until_finished(self.mvk, self.mvs)
-
-        # This will have triggered the primitive, so now we are back where we left off
-        # Just check whether or not the correct value is in the returnvalue to be used
-        self.assertEquals(get_inst(self.root, self.mvs), "call")
-        self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        execute_until_finished(self.mvk, self.mvs)
-
-        if a is not None:
-            self.assertEquals(get_returnvalue(self.root, self.mvs)["value"], result)
-        else:
-            self.assertEquals(get_returnvalue(self.root, self.mvs), a)

state/modelverse_state/main.py

@@ -12,7 +12,7 @@ if sys.version > '3': # pragma: no cover
 else: # pragma: no cover
     integer_types = (int, long)
     primitive_types = (int, long, float, str, bool, unicode)
-complex_primitives = frozenset(["if", "while", "assign", "call", "break", "continue", "return","resolve","access", "constant", "input", "output", "declare", "global", "Integer", "Float", "String", "Boolean", "Action", "Type"])
+complex_primitives = frozenset(["if", "while", "assign", "call", "break", "continue", "return","resolve","access", "constant", "input", "output", "declare", "global"])
 
 def instance_to_string(value):
     return value["value"]
@@ -139,12 +139,11 @@ class ModelverseState(object):
                 return False
         elif not isinstance(value, primitive_types):
             return False
-        elif isinstance(value, integer_types) and not (-2**63 <= value <= 2**64 - 1):
-            return False
         return True
 
     def create_nodevalue(self, value):
         if not self.is_valid_datavalue(value):
+            print("Not correct: " + str(value))
             return (None, status.FAIL_CNV_OOB)
         self.values[self.free_id] = value
         self.nodes.add(self.free_id)

state/test/test_create_dict.py

@@ -43,16 +43,3 @@ class TestCreateDict(unittest.TestCase):
         v, r = self.mvs.read_dict(id1, "abc")
         self.assertEquals(r, status.FAIL_RDICT_NOT_FOUND)
         self.assertEquals(v, None)
-
-    def test_create_dict_oob(self):
-        id1, r1 = self.mvs.create_node()
-        id2, r2 = self.mvs.create_node()
-        self.assertEquals(r1, status.SUCCESS)
-        self.assertEquals(r2, status.SUCCESS)
-
-        n, r = self.mvs.create_dict(id1, 9999999999999999999999999, id2)
-        self.assertEquals(r, status.FAIL_CDICT_OOB)
-
-        v, r = self.mvs.read_dict(id1, "abc")
-        self.assertEquals(r, status.FAIL_RDICT_NOT_FOUND)
-        self.assertEquals(v, None)

state/test/test_create_nodevalue.py

@@ -22,23 +22,6 @@ class TestCreateNodeValue(unittest.TestCase):
         self.assertEquals(r2, status.SUCCESS)
         self.assertEquals(val, 1)
 
-    def test_create_nodevalue_integer_oob_negative(self):
-        # Overflow towards minus infinity
-        for i in range(-2**63 - 10, -2**63):
-            id1, r = self.mvs.create_nodevalue(i)
-            self.assertEquals(r, status.FAIL_CNV_OOB)
-
-    def test_create_nodevalue_integer_ib_negative(self):
-        # Just within range
-        v = set()
-        size = 0
-        for i in range(-2**63, -2**63 + 10):
-            id1, r = self.mvs.create_nodevalue(i)
-            self.assertEquals(r, status.SUCCESS)
-            size += 1
-            v.add(id1)
-        self.assertEquals(len(v), size)
-
     def test_create_nodevalue_integer_ib_zero(self):
         # Nicely within range
         v = set()
@@ -50,23 +33,6 @@ class TestCreateNodeValue(unittest.TestCase):
             v.add(id1)
         self.assertEquals(len(v), size)
 
-    def test_create_nodevalue_integer_oob_positive(self):
-        # Overflow towards minus infinity
-        for i in range(2**64, 2**64+10):
-            id1, r = self.mvs.create_nodevalue(i)
-            self.assertEquals(r, status.FAIL_CNV_OOB)
-
-    def test_create_nodevalue_integer_ib_positive(self):
-        # Just within range
-        v = set()
-        size = 0
-        for i in range(2**64-10, 2**64):
-            id1, r = self.mvs.create_nodevalue(i)
-            self.assertEquals(r, status.SUCCESS)
-            size += 1
-            v.add(id1)
-        self.assertEquals(len(v), size)
-
     def test_create_nodevalue_boolean(self):
         id1, r1 = self.mvs.create_nodevalue(True)
         id2, r2 = self.mvs.create_nodevalue(False)
@@ -215,48 +181,6 @@ class TestCreateNodeValue(unittest.TestCase):
         v, r = self.mvs.read_value(id1)
         self.assertEquals(r, status.FAIL_RV_UNKNOWN)
 
-    def test_create_nodevalue_type_integer(self):
-        id1, r = self.mvs.create_nodevalue({"value": "Integer"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "Integer"})
-
-    def test_create_nodevalue_type_float(self):
-        id1, r = self.mvs.create_nodevalue({"value": "Float"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "Float"})
-
-    def test_create_nodevalue_type_string(self):
-        id1, r = self.mvs.create_nodevalue({"value": "String"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "String"})
-
-    def test_create_nodevalue_type_boolean(self):
-        id1, r = self.mvs.create_nodevalue({"value": "Boolean"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "Boolean"})
-
-    def test_create_nodevalue_type_action(self):
-        id1, r = self.mvs.create_nodevalue({"value": "Action"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "Action"})
-
-    def test_create_nodevalue_type_type(self):
-        id1, r = self.mvs.create_nodevalue({"value": "Type"})
-        self.assertEquals(r, status.SUCCESS)
-        v, r = self.mvs.read_value(id1)
-        self.assertEquals(r, status.SUCCESS)
-        self.assertEquals(v, {"value": "Type"})
-
     def test_create_nodevalue_action_input(self):
         id1, r = self.mvs.create_nodevalue({"value": "input"})
         self.assertEquals(r, status.SUCCESS)

state/test/test_read_dict_edge.py

@@ -68,14 +68,6 @@ class TestReadDictEdge(unittest.TestCase):
         self.assertEquals(r, status.SUCCESS)
         self.assertEquals(l, d)
 
-    def test_read_dict_edge_oob(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-
-        l, r = self.mvs.read_dict_edge(a, 9999999999999999999999)
-        self.assertEquals(r, status.FAIL_RDICTE_OOB)
-        self.assertEquals(l, None)
-
     def test_read_dict_edge_node_multi(self):
         a, r = self.mvs.create_node()
         self.assertEquals(r, status.SUCCESS)
@@ -129,30 +121,3 @@ class TestReadDictEdge(unittest.TestCase):
         l, r = self.mvs.read_dict_edge(a, "f")
         self.assertEquals(r, status.FAIL_RDICTE_UNCERTAIN)
         self.assertEquals(l, None)
-
-    """
-    def test_read_dict_edge_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_edge(a, "f")
-        self.assertEquals(l, None)
-        self.assertEquals(r, status.FAIL_RDICTE_AMBIGUOUS)
-    """

state/test/test_read_reverse_dict.py

@@ -52,15 +52,6 @@ class TestReadReverseDict(unittest.TestCase):
         self.assertEquals(l, None)
         self.assertEquals(r, status.FAIL_RRDICT_NOT_FOUND)
 
-    def test_read_reverse_dict_oob(self):
-        a, r = self.mvs.create_node()
-        self.assertEquals(r, status.SUCCESS)
-
-        # Passing data is not enforced, as the data will be interpreted if necessary
-        l, r = self.mvs.read_reverse_dict(a, 999999999999999999999999999999)
-        self.assertEquals(r, status.FAIL_RRDICT_OOB)
-        self.assertEquals(l, None)
-
     def test_read_reverse_dict_node_simple(self):
         a, r = self.mvs.create_node()
         self.assertEquals(r, status.SUCCESS)

state/test/test_read_value.py

@@ -21,16 +21,6 @@ class TestReadValue(unittest.TestCase):
         self.assertEquals(v1, 1)
         self.assertEquals(v2, 2)
 
-    def test_read_value_integer_oob_negative(self):
-        # Overflow towards minus infinity
-        for i in range(-2**63 - 10, -2**63):
-            id1, r = self.mvs.create_nodevalue(i)
-            self.assertEquals(r, status.FAIL_CNV_OOB)
-            self.assertEquals(id1, None)
-            v, r = self.mvs.read_value(id1)
-            self.assertEquals(r, status.FAIL_RV_UNKNOWN)
-            self.assertEquals(v, None)
-
     def test_read_value_integer_ib_negative(self):
         # Just within range
         for i in range(-2**63, -2**63 + 10):
@@ -49,16 +39,6 @@ class TestReadValue(unittest.TestCase):
             self.assertEquals(r, status.SUCCESS)
             self.assertEquals(v, i)
 
-    def test_read_value_integer_oob_positive(self):
-        # Overflow towards minus infinity
-        for i in range(2**64, 2**64+10):
-            id1, r = self.mvs.create_nodevalue(i)
-            self.assertEquals(r, status.FAIL_CNV_OOB)
-            self.assertEquals(id1, None)
-            v, r = self.mvs.read_value(id1)
-            self.assertEquals(r, status.FAIL_RV_UNKNOWN)
-            self.assertEquals(v, None)
-
     def test_read_value_integer_ib_positive(self):
         # Just within range
         for i in range(2**64-10, 2**64):