modelverse/integration/test_pn_interface.py

import unittest

from utils import run_file, get_constructor

set_inheritance = [
        "Which link in the metamodel is the inheritance link?",
        "Set inheritance link!",
    ]

do_instantiate_simple = [
            "new", "PetriNets", "abc",
            "instantiate", "Transition", "t1",
            "instantiate", "Place", "p1", "attr_add", "p1", "tokens", 5,
            "instantiate", "Place", "p2", "attr_add", "p2", "tokens", 0,
            "instantiate", "P2T", "p2t", "p1", "t1", "attr_add", "p2t", "weight", 2,
            "instantiate", "T2P", "t2p", "t1", "p2", "attr_add", "t2p", "weight", 1]

instantiate_node = ["Type to instantiate?",
                    "Name of new element?",
                    "Instantiation successful!"]

instantiate_edge = ["Type to instantiate?",
                    "Name of new element?",
                    "Source name?",
                    "Destination name?",
                    "Instantiation successful!"]

all_files = [   "pn_interface.alc",
                "primitives.alc",
                "object_operations.alc",
                "conformance_scd.alc",
                "library.alc",
                "transform.alc",
                "ramify.alc",
                "metamodels.alc",
                "random.alc",
                "constructors.alc",
                "modelling.alc",
                "compilation_manager.alc",
            ]

greeting =          ["Welcome to the Model Management Interface, running live on the Modelverse!",
                     "Use 'help' command for a list of possible commands"]
new =               ["Metamodel to instantiate?",
                     "Name of model?"]
prompt =            ["Please give your command."]
loaded =            ["Model loaded, ready for commands!",
                     "Use 'help' command for a list of possible commands"] + prompt
load =              ["Model to load?"]
instantiate =       ["Type to instantiate?"]
instantiate_name =  ["Name of new element?"]
instantiate_ok =    ["Instantiation successful!"]
instantiate_source= ["Source name?"]
instantiate_destination = ["Destination name?"]

def list_menu(defined):
    defined.append(("PetriNets", "SimpleClassDiagrams"))
    defined.append(("SimpleClassDiagrams", "SimpleClassDiagrams"))
    defined.append(("LTM_bottom", "LTM_bottom"))
    return ["Found models:",
            set(["  %s : %s" % (m, mm) for m, mm in defined])]

def list_model(defined):
    return ["List of all elements:",
            set(["  %s : %s" % (m, mm) for m, mm in defined])]

def read_node(name, t, defs, attrs):
    return ["Element to read?",
            "Name: %s" % name, 
            "Type: %s" % t,
            "Defines attributes:"] + \
            ([set(["  %s : %s" % (m, mm) for m, mm in defs])] if defs else []) + \
            ["Attributes:"] + \
            ([set(['  "%s" : "%s" = %s' % (m, mm, v) for m, mm, v in attrs])] if attrs else [])

def read_edge(name, t, src, dst, defs, attrs):
    return ["Element to read?",
            "Name: %s" % name, 
            "Type: %s" % t,
            "Source: %s" % src,
            "Destination: %s" % dst,
            "Defines attributes:"] + \
            ([set(["  %s : %s" % (m, mm) for m, mm in defs])] if defs else []) + \
            ["Attributes:"] + \
            ([set(['  "%s" : "%s" = %s' % (m, mm, v) for m, mm, v in attrs])] if attrs else [])

delete =            ["Model to delete?", "Deleted!"]
rename =            ["Old name?", "New name?", "Rename complete!"]
attr_add =          ["Which model do you want to assign an attribute to?",
                     "Which attribute do you wish to assign?",
                     "Value of attribute?",
                     "Added attribute!"]
attr_del =          ["Which model do you want to remove an attribute of?",
                     "Which attribute do you want to delete?",
                     "Attribute deleted!",
                    ]

help_root =         ["Currently no model is loaded, so your operations are limited to:",
                     "  new    -- Create a new model and save it for future use"
                     "  load   -- Load a previously made model",
                     "  rename -- Rename a previously made model",
                     "  delete -- Delete a previously made model",
                     "  list   -- Show a list of all stored models",
                     "  help   -- Show a list of possible commands"]
verify_fail_weight= ["Natural number not larger than or equal to zero"]
verify_fail_tokens= ["Natural number not larger than or equal to zero"]
verify_fail_structure = ["Source of model edge not typed by source of type: p2t"]

init = greeting + prompt

did_instantiate_simple = init + \
                         new + \
                         loaded +\
                         instantiate_node + \
                         prompt + \
                         instantiate_node + \
                         prompt + \
                         attr_add + \
                         prompt + \
                         instantiate_node + \
                         prompt + \
                         attr_add + \
                         prompt + \
                         instantiate_edge + \
                         prompt + \
                         attr_add + \
                         prompt + \
                         instantiate_edge + \
                         prompt + \
                         attr_add + \
                         prompt

def list_types(t):
    return ["List of types:"] + \
            [set(["  %s : %s" % (m, mm) for m, mm in t])]

modify =            ["Element to modify?", 
                     "Attribute to modify?",
                     "New value?",
                     "Modified!",]

class TestPetrinetInterface(unittest.TestCase):
    def test_po_pn_interface_manage(self):
        self.pn_interface_manage("PO")

    def test_co_pn_interface_manage(self):
        self.pn_interface_manage("CO")

    def pn_interface_manage(self, mode):
        self.assertTrue(run_file(all_files,
            ["list",
             "new", "PetriNets", "abc", "exit",
             "list",
             "new", "PetriNets", "def", "exit",
             "list",
             "delete", "def",
             "list",
             "rename", "abc", "a",
             "list",
             "delete", "a",
             "list",
             ],
            init + \
                list_menu([]) + prompt + \
                new + loaded + prompt + list_menu([("abc", "PetriNets")]) + prompt + \
                new + loaded + prompt + list_menu([("abc", "PetriNets"), ("def", "PetriNets")]) + prompt + \
                delete + prompt + list_menu([("abc", "PetriNets")]) + prompt + \
                rename + prompt + list_menu([("a", "PetriNets")]) + prompt + \
                delete + prompt + list_menu([]) + prompt,
            mode))

    def test_po_pn_interface_new_reload(self):
        self.pn_interface_new_reload("PO")

    def test_co_pn_interface_new_reload(self):
        self.pn_interface_new_reload("CO")

    def pn_interface_new_reload(self, mode):
        self.assertTrue(run_file(all_files,
            ["new", "PetriNets", "abc", "exit", "load", "abc"],
            init + new + loaded + prompt + load + loaded,
            mode))

    def test_po_pn_interface_instantiate_place(self):
        self.pn_interface_instantiate_place("PO")

    def test_co_pn_interface_instantiate_place(self):
        self.pn_interface_instantiate_place("CO")

    def pn_interface_instantiate_place(self, mode):
        self.assertTrue(run_file(all_files,
            ["new", "PetriNets", "abc",
            "instantiate", "Place", "p1",
            "attr_add", "p1", "tokens", 5,
            "list",
            "read", "p1",
            "instantiate", "Transition", "t1",
            "list",
            "read", "t1"],
            init + new + loaded + \
                instantiate_node + prompt + \
                attr_add + prompt + \
                list_model([("p1", "Place"), ("p1.tokens", "Natural")]) + prompt + \
                read_node("p1", "Place", [], [("tokens", "Natural", 5)]) + prompt + \
                instantiate_node + prompt + \
                list_model([("p1", "Place"), ("t1", "Transition"), ("p1.tokens", "Natural")]) + prompt + \
                read_node("t1", "Transition", [], []) + prompt,
            mode))

    def test_po_pn_interface_instantiate_arcs(self):
        self.pn_interface_instantiate_arcs("PO")

    def test_co_pn_interface_instantiate_arcs(self):
        self.pn_interface_instantiate_arcs("CO")

    def pn_interface_instantiate_arcs(self, mode):
        self.assertTrue(run_file(all_files,
            do_instantiate_simple + [
                    "read", "p1",
                    "read", "p2",
                    "read", "t1",
                    "read", "p2t",
                    "read", "t2p",
                ],
            did_instantiate_simple + \
                read_node("p1", "Place", [], [("tokens", "Natural", 5)]) + prompt + \
                read_node("p2", "Place", [], [("tokens", "Natural", 0)]) + prompt + \
                read_node("t1", "Transition", [], []) + prompt + \
                read_edge("p2t", "P2T", "p1", "t1", [], [("weight", "Natural", 2)]) + prompt + \
                read_edge("t2p", "T2P", "t1", "p2", [], [("weight", "Natural", 1)]) + prompt,
            mode))

    def test_po_pn_interface_verify_OK(self):
        self.pn_interface_verify_OK("PO")

    def test_co_pn_interface_verify_OK(self):
        self.pn_interface_verify_OK("CO")

    def pn_interface_verify_OK(self, mode):
        self.assertTrue(run_file(all_files,
            do_instantiate_simple + ["verify"],
            did_instantiate_simple + ["OK"], mode))

    def test_po_pn_interface_verify_fail_tokens(self):
        self.pn_interface_verify_fail_tokens("PO")

    def test_co_pn_interface_verify_fail_tokens(self):
        self.pn_interface_verify_fail_tokens("CO")

    def pn_interface_verify_fail_tokens(self, mode):
        self.assertTrue(run_file(all_files,
            do_instantiate_simple + ["modify", "p1", "tokens", -5, "verify"],
            did_instantiate_simple + modify + prompt + verify_fail_tokens + prompt, mode))

    def test_po_pn_interface_verify_fail_weight(self):
        self.pn_interface_verify_fail_weight("PO")

    def test_co_pn_interface_verify_fail_weight(self):
        self.pn_interface_verify_fail_weight("CO")

    def pn_interface_verify_fail_weight(self, mode):
        self.assertTrue(run_file(all_files,
            do_instantiate_simple + ["modify", "p2t", "weight", -2, "verify"],
            did_instantiate_simple + modify + prompt + verify_fail_weight + prompt, mode))

    def test_po_pn_interface_verify_fail_structure(self):
        self.pn_interface_verify_fail_structure("PO")

    def test_co_pn_interface_verify_fail_structure(self):
        self.pn_interface_verify_fail_structure("CO")

    def pn_interface_verify_fail_structure(self, mode):
        self.assertTrue(run_file(all_files,
            ["new", "PetriNets", "abc",
            "instantiate", "Transition", "t1",
            "instantiate", "Place", "p1", "attr_add", "p1", "tokens", 5,
            "instantiate", "P2T", "p2t", "t1", "p1", "attr_add", "p2t", "weight", 2, "verify"],
            init + new + loaded + \
                instantiate_node + prompt + \
                instantiate_node + prompt + attr_add + prompt + \
                instantiate_edge + prompt + attr_add + prompt + \
                verify_fail_structure,
            mode))

    def test_po_pn_interface_types(self):
        self.pn_interface_types("PO")

    def test_co_pn_interface_types(self):
        self.pn_interface_types("CO")

    def pn_interface_types(self, mode):
        self.assertTrue(run_file(all_files,
            ["new", "PetriNets", "abc", "types"],
            init + new + loaded + list_types([("Place", "Class"),
                                              ("Transition", "Class"),
                                              ("P2T", "Association"),
                                              ("T2P", "Association"),
                                              ("Natural", "Class"),
                                              ("Place_tokens", "Association"),
                                              ("Place_tokens.name", "String"),
                                              ("Place_tokens.target_lower_cardinality", "Natural"),
                                              ("Place_tokens.target_upper_cardinality", "Natural"),
                                              ("P2T_weight", "Association"),
                                              ("P2T_weight.name", "String"),
                                              ("P2T_weight.target_lower_cardinality", "Natural"),
                                              ("P2T_weight.target_upper_cardinality", "Natural"),
                                              ("T2P_weight", "Association"),
                                              ("T2P_weight.name", "String"),
                                              ("T2P_weight.target_lower_cardinality", "Natural"),
                                              ("T2P_weight.target_upper_cardinality", "Natural"),
                    ]) + prompt,
            mode))

    def test_po_pn_interface_modify_place(self):
        self.pn_interface_modify_place("PO")

    def test_co_pn_interface_modify_place(self):
        self.pn_interface_modify_place("CO")

    def pn_interface_modify_place(self, mode):
        self.assertTrue(run_file(all_files,
            ["new", "PetriNets", "abc",
                "instantiate", "Place", "p1", "attr_add", "p1", "tokens", 5,
                "read", "p1",
                "modify", "p1", "tokens", 1, "read", "p1"],
            init + new + loaded + \
                instantiate_node + prompt + attr_add + prompt + \
                read_node("p1", "Place", [], [("tokens", "Natural", 5)]) + prompt + \
                modify + prompt + \
                read_node("p1", "Place", [], [("tokens", "Natural", 1)]) + prompt,
            mode))

    def test_po_pn_interface_verify_fail_attr_lower_cardinality(self):
        self.pn_interface_verify_fail_attr_lower_cardinality("PO")

    def test_co_pn_interface_verify_fail_attr_lower_cardinality(self):
        self.pn_interface_verify_fail_attr_lower_cardinality("CO")

    def pn_interface_verify_fail_attr_lower_cardinality(self, mode):
        self.assertTrue(run_file(all_files,
            do_instantiate_simple + ["instantiate", "Place", "p999", "verify"],
            did_instantiate_simple + instantiate_node + prompt + ["Lower cardinality violation for outgoing edge of type Place_tokens at p999"] + prompt,
            mode))

    def test_po_pn_interface_verify_fail_attr_upper_cardinality(self):
        self.pn_interface_verify_fail_attr_upper_cardinality("PO")

    def test_co_pn_interface_verify_fail_attr_upper_cardinality(self):
        self.pn_interface_verify_fail_attr_upper_cardinality("CO")

    def pn_interface_verify_fail_attr_upper_cardinality(self, mode):
        self.assertTrue(run_file(all_files,
            do_instantiate_simple + ["attr_add", "p1", "tokens", 5, "verify"],
            did_instantiate_simple + attr_add + prompt + ["Upper cardinality violation for outgoing edge of type Place_tokens at p1"] + prompt,
            mode))

    def test_po_pn_interface_verify_natural(self):
        self.pn_interface_verify_natural("PO")

    def test_co_pn_interface_verify_natural(self):
        self.pn_interface_verify_natural("CO")

    def pn_interface_verify_natural(self, mode):
        self.assertTrue(run_file(all_files,
            ["new", "PetriNets", "abc",
            "instantiate", "Place", "p1",
            "attr_add", "p1", "tokens", -5,
            "attr_del", "p1", "tokens",
            "attr_add", "p1", "tokens", 4,
            "verify"],
            init + new + loaded + \
            instantiate_node + prompt + \
            attr_add + prompt + \
            attr_del + prompt + \
            attr_add + prompt + \
            ["OK"] + prompt,
            mode))

    def test_po_pn_interface_verify_PN_OK(self):
        self.pn_interface_verify_PN_OK("PO")

    def test_co_pn_interface_verify_PN_OK(self):
        self.pn_interface_verify_PN_OK("CO")

    def pn_interface_verify_PN_OK(self, mode):
        self.assertTrue(run_file(all_files,
            ["load", "PetriNets", "verify"],
            init + load + loaded + ["OK"], mode))

    def test_po_rpgame(self):
        self.rpgame("PO")

    def test_co_rpgame(self):
        self.rpgame("CO")

    def rpgame(self, mode):

        constraint_code = \
            """
include "primitives.alh"
include "object_operations.alh"

Element function constraint(model : Element, name : String):
\tElement associations
\tElement back_associations
\tElement association
\tString destination
\tassociations = allOutgoingAssociationInstances(model, name, "tile_left")
\twhile (0 < list_len(associations)):
\t\tassociation = set_pop(associations)
\t\tdestination = readAssociationDestination(model, association)
\t\tback_associations = allOutgoingAssociationInstances(model, destination, "tile_right")
\t\tif (list_len(back_associations) < 1):
\t\t\treturn "Left link does not have a right link back"!
\t\telse:
\t\t\tassociation = set_pop(back_associations)
\t\t\tdestination = readAssociationDestination(model, association)
\t\t\tif (destination != name):
\t\t\t\treturn "Right link does not have a left link back to the same tile"!
\tassociations = allOutgoingAssociationInstances(model, name, "tile_right")
\twhile (0 < list_len(associations)):
\t\tassociation = set_pop(associations)
\t\tdestination = readAssociationDestination(model, association)
\t\tback_associations = allOutgoingAssociationInstances(model, destination, "tile_left")
\t\tif (list_len(back_associations) < 1):
\t\t\treturn "Right link does not have a left link back"!
\t\telse:
\t\t\tassociation = set_pop(back_associations)
\t\t\tdestination = readAssociationDestination(model, association)
\t\t\tif (destination != name):
\t\t\t\treturn "Right link does not have a left link back to the same tile"!
\tassociations = allOutgoingAssociationInstances(model, name, "tile_top")
\twhile (0 < list_len(associations)):
\t\tassociation = set_pop(associations)
\t\tdestination = readAssociationDestination(model, association)
\t\tback_associations = allOutgoingAssociationInstances(model, destination, "tile_bottom")
\t\tif (list_len(back_associations) < 1):
\t\t\treturn "Top link does not have a bottom link back"!
\t\telse:
\t\t\tassociation = set_pop(back_associations)
\t\t\tdestination = readAssociationDestination(model, association)
\t\t\tif (destination != name):
\t\t\t\treturn "Top link does not have a bottom link back to the same tile"!
\tassociations = allOutgoingAssociationInstances(model, name, "tile_bottom")
\twhile (0 < list_len(associations)):
\t\tassociation = set_pop(associations)
\t\tdestination = readAssociationDestination(model, association)
\t\tback_associations = allOutgoingAssociationInstances(model, destination, "tile_top")
\t\tif (list_len(back_associations) < 1):
\t\t\treturn "Bottom link does not have a top link back"!
\t\telse:
\t\t\tassociation = set_pop(back_associations)
\t\t\tdestination = readAssociationDestination(model, association)
\t\t\tif (destination != name):
\t\t\t\treturn "Bottom link does not have a top link back to the same tile"!
\treturn "OK"!
            """

        constructors = get_constructor(constraint_code)

        self.assertTrue(run_file(all_files,
            ["new", "SimpleClassDiagrams", "RPGame",
                "set_inheritance", "Inheritance",
                "instantiate", "Class", "Scene",
                "instantiate", "Class", "Tile",
                "instantiate", "Class", "Item",
                "instantiate", "Class", "Goal",
                "instantiate", "Class", "Character",
                "instantiate", "Class", "Hero",
                "instantiate", "Association", "scene_has_tiles", "Scene", "Tile",
                "instantiate", "Association", "tile_left", "Tile", "Tile",
                "instantiate", "Association", "tile_right", "Tile", "Tile",
                "instantiate", "Association", "tile_top", "Tile", "Tile",
                "instantiate", "Association", "tile_bottom", "Tile", "Tile",
                "instantiate", "Association", "character_on", "Character", "Tile",
                "instantiate", "Association", "item_on", "Item", "Tile",
                "instantiate", "Inheritance", "hero_is_character", "Hero", "Character",
                "instantiate", "Inheritance", "goal_is_item", "Goal", "Item",
                "attr_add", "Scene", "lower_cardinality", 1,
                "attr_add", "Scene", "upper_cardinality", 1,
                "attr_add", "Goal", "lower_cardinality", 1,
                "attr_add", "scene_has_tiles", "source_lower_cardinality", 1,
                "attr_add", "scene_has_tiles", "source_upper_cardinality", 1,
                "attr_add", "scene_has_tiles", "target_lower_cardinality", 1,
                "attr_add", "item_on", "target_lower_cardinality", 1,
                "attr_add", "item_on", "target_upper_cardinality", 1,
                "attr_add", "item_on", "source_upper_cardinality", 1,
                "attr_add", "character_on", "target_lower_cardinality", 1,
                "attr_add", "character_on", "target_upper_cardinality", 1,
                "attr_add", "character_on", "source_upper_cardinality", 1,
                "attr_add", "tile_left", "source_upper_cardinality", 1,
                "attr_add", "tile_left", "target_upper_cardinality", 1,
                "attr_add", "tile_right", "source_upper_cardinality", 1,
                "attr_add", "tile_right", "target_upper_cardinality", 1,
                "attr_add", "tile_top", "source_upper_cardinality", 1,
                "attr_add", "tile_top", "target_upper_cardinality", 1,
                "attr_add", "tile_bottom", "source_upper_cardinality", 1,
                "attr_add", "tile_bottom", "target_upper_cardinality", 1,
                "attr_add_code", "Tile", "constraint",
            ] + constructors + ["verify"] + ["exit"] + [
                "new", "RPGame", "my_game",
                "instantiate", "Scene", "scene",
                "instantiate", "Hero", "Link",
                "instantiate", "Goal", "goal",
                "instantiate", "Tile", "tile_00",
                "instantiate", "Tile", "tile_01",
                "instantiate", "Tile", "tile_10",
                "instantiate", "Tile", "tile_11",
                "instantiate", "scene_has_tiles", "", "scene", "tile_00",
                "instantiate", "scene_has_tiles", "", "scene", "tile_01",
                "instantiate", "scene_has_tiles", "", "scene", "tile_10",
                "instantiate", "scene_has_tiles", "", "scene", "tile_11",
                "instantiate", "character_on", "",  "Link", "tile_00",
                "instantiate", "item_on", "", "goal", "tile_11",
                "instantiate", "tile_left", "", "tile_01", "tile_00",
                "instantiate", "tile_left", "", "tile_11", "tile_10",
                "instantiate", "tile_right", "", "tile_00", "tile_01",
                "instantiate", "tile_right", "", "tile_10", "tile_11",
                "instantiate", "tile_top", "", "tile_10", "tile_00",
                "instantiate", "tile_top", "", "tile_11", "tile_01",
                "instantiate", "tile_bottom", "", "tile_00", "tile_10",
                "instantiate", "tile_bottom", "", "tile_01", "tile_11",
                "verify",
            ],
            init + new + loaded + \
                set_inheritance + prompt + \
                (instantiate_node + prompt) * 6 + \
                (instantiate_edge + prompt) * 9 + \
                (attr_add + prompt) * 20 + \
                ["Element to constrain (empty for global)?",
                 "Give input to function constructors for LOCAL constraint!",
                 "Added constraint to model!"] + \
                prompt + \
                ["OK"] + \
                prompt + prompt + new + loaded + \
                (instantiate_node + prompt) * 7 + \
                (instantiate_edge + prompt) * 14 + \
                ["OK"],
            mode))

    def test_po_pn_interface_transform_pn(self):
        code_mark_constraint = \
            """
include "primitives.alh"
include "modelling.alh"
include "object_operations.alh"
Boolean function constraint(host_model : Element, name : String):
\t// Make sure that all places have enough tokens
\tElement links
\tString link
\tString place
\tlinks = allIncomingAssociationInstances(host_model, name, "P2T")
\twhile (read_nr_out(links) > 0):
\t\tlink = set_pop(links)
\t\tplace = readAssociationSource(host_model, link)
\t\tlog("Check link " + link)
\t\tlog("Check place " + place)
\t\tif (integer_lt(read_attribute(host_model, place, "tokens"), read_attribute(host_model, link, "weight"))):
\t\t\t// Not enough tokens for this weight
\t\t\treturn False!
\treturn True!
            """

        code_mark_action = \
            """
include "primitives.alh"
include "modelling.alh"
Void function action(host_model : Element, name : String, mapping : Element):
\tunset_attribute(host_model, name, "executing")
\tinstantiate_attribute(host_model, name, "executing", True)
\treturn!
            """

        code_consume_transition_constraint = \
            """
include "primitives.alh"
include "modelling.alh"
Boolean function constraint(host_model : Element, name : String):
\t// Check if this node is executing currently
\treturn value_eq(read_attribute(host_model, name, "executing"), True)!
            """

        code_consume_place_constraint = \
            """
include "primitives.alh"
include "modelling.alh"
Boolean function constraint(host_model : Element, name : String):
\t// Check if this node is executing currently
\treturn value_eq(read_attribute(host_model, name, "executed"), False)!
            """

        code_consume_place_action = \
            """
include "primitives.alh"
include "modelling.alh"
Void function action(host_model : Element, name : String, mapping : Element):
\tInteger tokens
\tInteger weight
\ttokens = read_attribute(host_model, name, "tokens")
\tweight = read_attribute(host_model, mapping["2"], "weight")
\tunset_attribute(host_model, name, "tokens")
\tinstantiate_attribute(host_model, name, "tokens", tokens - weight)
\tunset_attribute(host_model, name, "executed")
\tinstantiate_attribute(host_model, name, "executed", True)
\treturn!
            """

        code_produce_place_action = \
            """
include "primitives.alh"
include "modelling.alh"
Void function action(host_model : Element, name : String, mapping : Element):
\tInteger tokens
\tInteger weight
\ttokens = read_attribute(host_model, name, "tokens")
\tweight = read_attribute(host_model, mapping["2"], "weight")
\tunset_attribute(host_model, name, "tokens")
\tinstantiate_attribute(host_model, name, "tokens", tokens + weight)
\tunset_attribute(host_model, name, "executed")
\tinstantiate_attribute(host_model, name, "executed", True)
\treturn!
            """

        code_unmark_transition_constraint = \
            """
include "primitives.alh"
include "modelling.alh"
Boolean function constraint(host_model : Element, name : String):
\t// Check if this node is executing currently
\treturn value_eq(read_attribute(host_model, name, "executing"), True)!
            """

        code_unmark_place_constraint = \
            """
include "primitives.alh"
include "modelling.alh"
Boolean function constraint(host_model : Element, name : String):
\t// Check if this node is executing currently
\treturn value_eq(read_attribute(host_model, name, "executed"), True)!
            """

        code_unmark_transition_action = \
            """
include "primitives.alh"
include "modelling.alh"
Void function action(host_model : Element, name : String, mapping : Element):
\tunset_attribute(host_model, name, "executing")
\tinstantiate_attribute(host_model, name, "executing", False)
\treturn!
            """

        code_unmark_place_action = \
            """
include "primitives.alh"
include "modelling.alh"
Void function action(host_model : Element, name : String, mapping : Element):
\tunset_attribute(host_model, name, "executed")
\tinstantiate_attribute(host_model, name, "executed", False)
\treturn!
            """

        constructor_mark_constraint = get_constructor(code_mark_constraint)
        constructor_mark_action = get_constructor(code_mark_action)

        constructor_consume_transition_constraint = get_constructor(code_consume_transition_constraint)
        constructor_consume_place_constraint = get_constructor(code_consume_place_constraint)
        constructor_consume_place_action = get_constructor(code_consume_place_action)

        constructor_produce_transition_constraint = constructor_consume_transition_constraint
        constructor_produce_place_constraint = constructor_consume_place_constraint
        constructor_produce_place_action = get_constructor(code_produce_place_action)

        constructor_unmark_transition_constraint = constructor_consume_transition_constraint
        constructor_unmark_transition_action = get_constructor(code_unmark_transition_action)

        constructor_unmark_place_constraint = get_constructor(code_unmark_place_constraint)
        constructor_unmark_place_action = get_constructor(code_unmark_place_action)

        self.assertTrue(run_file(all_files,
            ["new", "SimpleClassDiagrams", "PetriNets_runtime",
                "set_inheritance", "Inheritance",
                "instantiate", "Class", "Natural",
                "instantiate", "Class", "Boolean",
                "instantiate", "Class", "Place",
                "attr_def", "Place", "tokens", "Natural",
                "attr_def", "Place", "executed", "Boolean",
                "instantiate", "Class", "Transition",
                "attr_def", "Transition", "executing", "Boolean",
                "instantiate", "Association", "P2T", "Place", "Transition",
                "attr_def", "P2T", "weight", "Natural",
                "instantiate", "Association", "T2P", "Transition", "Place",
                "attr_def", "T2P", "weight", "Natural",
                "exit",
             "new", "PetriNets_runtime", "pn",
                "instantiate", "Place", "p1",
                "attr_add", "p1", "tokens", 1,
                "attr_add", "p1", "executed", False,
                "instantiate", "Place", "p2",
                "attr_add", "p2", "tokens", 2,
                "attr_add", "p2", "executed", False,
                "instantiate", "Transition", "t1",
                "attr_add", "t1", "executing", False,
                "instantiate", "P2T", "p2t", "p1", "t1",
                "attr_add", "p2t", "weight", 1,
                "instantiate", "P2T", "p2t2", "p2", "t1",
                "attr_add", "p2t2", "weight", 1,
                "exit",
             "ramify", "PetriNets_runtime",
             "new", "PetriNets_runtime_SCHEDULE", "pn_simulate",
                # Rule 1: mark transition to execute
                # LHS
                "instantiate", "LHS", "lhs_mark",
                "instantiate", "Pre_Transition", "pre_mark_t",
                "attr_add", "pre_mark_t", "label", "0",
                "attr_add_code", "pre_mark_t", "constraint", 
            ] + constructor_mark_constraint + [
                "instantiate", "LHS_contains", "", "lhs_mark", "pre_mark_t",
                # RHS
                "instantiate", "RHS", "rhs_mark",
                "instantiate", "Post_Transition", "post_mark_t",
                "attr_add", "post_mark_t", "label", "0",
                "attr_add_code", "post_mark_t", "action",
            ] + constructor_mark_action + [
                "instantiate", "RHS_contains", "", "rhs_mark", "post_mark_t",
                # Atomic of rule 1 "mark"
                "instantiate", "Atomic", "mark",
                "instantiate", "AtomicLHS", "", "mark", "lhs_mark",
                "instantiate", "AtomicRHS", "", "mark", "rhs_mark",
                # Rule 2: consume tokens going into marked transition
                # LHS
                "instantiate", "LHS", "lhs_consume",
                "instantiate", "Pre_Transition", "pre_consume_t",
                "attr_add", "pre_consume_t", "label", "0",
                "attr_add_code", "pre_consume_t", "constraint",
            ] + constructor_consume_transition_constraint + [
                "instantiate", "Pre_Place", "pre_consume_p",
                "attr_add", "pre_consume_p", "label", "1",
                "attr_add_code", "pre_consume_p", "constraint",
            ] + constructor_consume_place_constraint + [
                "instantiate", "Pre_P2T", "pre_consume_p2t", "pre_consume_p", "pre_consume_t",
                "attr_add", "pre_consume_p2t", "label", "2",
                "instantiate", "LHS_contains", "", "lhs_consume", "pre_consume_t",
                "instantiate", "LHS_contains", "", "lhs_consume", "pre_consume_p",
                "instantiate", "LHS_contains", "", "lhs_consume", "pre_consume_p2t",
                # RHS
                "instantiate", "RHS", "rhs_consume",
                "instantiate", "Post_Transition", "post_consume_t",
                "attr_add", "post_consume_t", "label", "0",
                "instantiate", "Post_Place", "post_consume_p",
                "attr_add", "post_consume_p", "label", "1",
                "attr_add_code", "post_consume_p", "action", 
            ] + constructor_consume_place_action + [
                "instantiate", "Post_P2T", "post_consume_p2t", "post_consume_p", "post_consume_t",
                "attr_add", "post_consume_p2t", "label", "2",
                "instantiate", "RHS_contains", "", "rhs_consume", "post_consume_t",
                "instantiate", "RHS_contains", "", "rhs_consume", "post_consume_p",
                "instantiate", "RHS_contains", "", "rhs_consume", "post_consume_p2t",
                # Atomic of rule 2 "consume"
                "instantiate", "Atomic", "consume",
                "instantiate", "AtomicLHS", "", "consume", "lhs_consume",
                "instantiate", "AtomicRHS", "", "consume", "rhs_consume",
                # Rule 3: produce tokens going out of marked transition
                # LHS
                "instantiate", "LHS", "lhs_produce",
                "instantiate", "Pre_Transition", "pre_produce_t",
                "attr_add", "pre_produce_t", "label", "0",
                "attr_add_code", "pre_produce_t", "constraint",
            ] + constructor_produce_transition_constraint + [
                "instantiate", "Pre_Place", "pre_produce_p",
                "attr_add", "pre_produce_p", "label", "1",
                "attr_add_code", "pre_produce_p", "constraint",
            ] + constructor_produce_place_constraint + [
                "instantiate", "Pre_T2P", "pre_produce_t2p", "pre_produce_t", "pre_produce_p",
                "attr_add", "pre_produce_t2p", "label", "2",
                "instantiate", "LHS_contains", "", "lhs_produce", "pre_produce_t",
                "instantiate", "LHS_contains", "", "lhs_produce", "pre_produce_p",
                "instantiate", "LHS_contains", "", "lhs_produce", "pre_produce_t2p",
                # RHS
                "instantiate", "RHS", "rhs_produce",
                "instantiate", "Post_Transition", "post_produce_t",
                "attr_add", "post_produce_t", "label", "0",
                "instantiate", "Post_Place", "post_produce_p",
                "attr_add", "post_produce_p", "label", "1",
                "attr_add_code", "post_produce_p", "action", 
            ] + constructor_produce_place_action + [
                "instantiate", "Post_T2P", "post_produce_t2p", "post_produce_t", "post_produce_p",
                "attr_add", "post_produce_t2p", "label", "2",
                "instantiate", "RHS_contains", "", "rhs_produce", "post_produce_t",
                "instantiate", "RHS_contains", "", "rhs_produce", "post_produce_p",
                "instantiate", "RHS_contains", "", "rhs_produce", "post_produce_t2p",
                # Atomic of rule 3 "produce"
                "instantiate", "Atomic", "produce",
                "instantiate", "AtomicLHS", "", "produce", "lhs_produce",
                "instantiate", "AtomicRHS", "", "produce", "rhs_produce",
                # Rule 4: unmark marked transition
                # LHS
                "instantiate", "LHS", "lhs_unmark_transition",
                "instantiate", "Pre_Transition", "pre_unmark_t",
                "attr_add", "pre_unmark_t", "label", "0",
                "attr_add_code", "pre_unmark_t", "constraint",
            ] + constructor_unmark_transition_constraint + [
                "instantiate", "LHS_contains", "", "lhs_unmark_transition", "pre_unmark_t",
                # RHS
                "instantiate", "RHS", "rhs_unmark_transition",
                "instantiate", "Post_Transition", "post_unmark_t",
                "attr_add", "post_unmark_t", "label", "0",
                "attr_add_code", "post_unmark_t", "action", 
            ] + constructor_unmark_transition_action + [
                "instantiate", "RHS_contains", "", "rhs_unmark_transition", "post_unmark_t",
                # Atomic of rule 4 "unmark transition"
                "instantiate", "Atomic", "unmark_transition",
                "instantiate", "AtomicLHS", "", "unmark_transition", "lhs_unmark_transition",
                "instantiate", "AtomicRHS", "", "unmark_transition", "rhs_unmark_transition",
                # Rule 5: unmark marked places
                # LHS
                "instantiate", "LHS", "lhs_unmark_place",
                "instantiate", "Pre_Place", "pre_unmark_p",
                "attr_add", "pre_unmark_p", "label", "0",
                "attr_add_code", "pre_unmark_p", "constraint",
            ] + constructor_unmark_place_constraint + [
                "instantiate", "LHS_contains", "", "lhs_unmark_place", "pre_unmark_p",
                # RHS
                "instantiate", "RHS", "rhs_unmark_place",
                "instantiate", "Post_Place", "post_unmark_p",
                "attr_add", "post_unmark_p", "label", "0",
                "attr_add_code", "post_unmark_p", "action", 
            ] + constructor_unmark_place_action + [
                "instantiate", "RHS_contains", "", "rhs_unmark_place", "post_unmark_p",
                # Atomic of rule 5 "unmark place"
                "instantiate", "Atomic", "unmark_place",
                "instantiate", "AtomicLHS", "", "unmark_place", "lhs_unmark_place",
                "instantiate", "AtomicRHS", "", "unmark_place", "rhs_unmark_place",
                # Compose schedule
                "instantiate", "Composite", "main",
                "instantiate", "Success", "success",
                "instantiate", "Failure", "failure",
                # Add all rules
                "instantiate", "Contains", "", "main", "success",
                "instantiate", "Contains", "", "main", "failure",
                "instantiate", "Contains", "", "main", "mark",
                "instantiate", "Contains", "", "main", "consume",
                "instantiate", "Contains", "", "main", "produce",
                "instantiate", "Contains", "", "main", "unmark_transition",
                "instantiate", "Contains", "", "main", "unmark_place",
                # Scheduling order
                "instantiate", "OnSuccess", "", "mark", "consume",
                "instantiate", "OnFailure", "", "mark", "success",
                "instantiate", "OnSuccess", "", "consume", "consume",
                "instantiate", "OnFailure", "", "consume", "produce",
                "instantiate", "OnSuccess", "", "produce", "produce",
                "instantiate", "OnFailure", "", "produce", "unmark_transition",
                "instantiate", "OnSuccess", "", "unmark_transition", "unmark_place",
                "instantiate", "OnFailure", "", "unmark_transition", "failure",
                "instantiate", "OnSuccess", "", "unmark_place", "unmark_place",
                "instantiate", "OnFailure", "", "unmark_place", "success",
                # Composite initial
                "instantiate", "Initial", "", "main", "mark",
                "exit",
             "transform", "pn", "pn_simulate",
             "load", "pn",
                "list",
                "verify",
                "read", "t1",
                "read", "p1",
                "read", "p2",
                "exit",
                ],
            None, "PO"))