Add some initial tests for process_signature and added an additional check

bootstrap/core_algorithm.alc

@@ -1159,15 +1159,22 @@ String function cmd_process_signature(process : String):
 		if (allow_execute(current_user_id, process_id)):
 			Element pm
 			pm = get_full_model(process_id, get_entry_id("formalisms/ProcessModel"))
+			
 			if (element_eq(pm, read_root())):
-				return "Specified model cannot be interpreted as a ProcessModel: " + process!
+				return "Not a ProcessModel: " + process!
 
 			result = "Success: "
 			signature = PM_signature(pm)
 			keys = dict_keys(signature)
+			Element found_keys
+			found_keys = set_create()
 			while (set_len(keys) > 0):
 				key = set_pop(keys)
 				result = result + key + " : " + cast_string(signature[key]) + "\n"
+				if set_in(found_keys, key):
+					return "Not a valid ProcessModel: " + process!
+				else:
+					set_add(found_keys, key)
 
 			return result!
 		else:

unit/test_all.py

@@ -4752,9 +4752,127 @@ class TestModelverse(unittest.TestCase):
         except NotAnActivity:
             pass
 
+    def test_op_process_signature(self):
+        # Add simple process
+        model_add("users/user/test/a", "formalisms/ProcessModel", """
+            Data a {
+                name = "abc"
+                type = "def"
+            }
+            """)
+
+        # Query its signature
+        assert process_signature("users/user/test/a") == {"abc": "def"}
+
+        # Add process with some operations
+        model_add("users/user/test/b", "formalisms/ProcessModel", """
+            Start start {}
+            Finish finish {}
+            Exec initializePN {
+                name = "users/user/test/initialize_PN"
+            }
+            Exec refinePN {
+                name = "users/user/test/refine_PN"
+            }
+            Exec reachability {
+                name = "users/user/test/reachability"
+            }
+            Exec reachability_print{
+                name = "users/user/test/reachability_print"
+            }
+
+            Data pn {
+                name = "pn"
+                type = "users/user/test/PetriNet"
+            }
+            Data reachability_graph {
+                name = "reachability"
+                type = "users/user/test/ReachabilityGraph"
+            }
+
+            Next (start, initializePN) {}
+            Next (initializePN, refinePN) {}
+            Next (refinePN, reachability) {}
+            Next (reachability, reachability_print) {}
+            Next (reachability_print, finish) {}
+
+            Produces (initializePN, pn) {
+                name = "PetriNet"
+            }
+            Consumes (refinePN, pn) {
+                name = "PetriNet"
+            }
+            Produces (refinePN, pn) {
+                name = "PetriNet"
+            }
+            Consumes (reachability, pn) {
+                name = "PetriNet"
+            }
+            Produces (reachability, reachability_graph) {
+                name = "ReachabilityGraph"
+            }
+            Consumes (reachability_print, reachability_graph) {
+                name = "ReachabilityGraph"
+            }
+            """)
+
+        # Query its signature
+        assert process_signature("users/user/test/b") == {"pn": "users/user/test/PetriNet", "reachability": "users/user/test/ReachabilityGraph"}
+
+        # Empty model
+        model_add("users/user/test/c", "formalisms/ProcessModel")
+        assert process_signature("users/user/test/c") == {}
+
+        # Multiple with same name (and same type)
+        model_add("users/user/test/d", "formalisms/ProcessModel", """
+            Data {
+                name = "a"
+                type = "b"
+            }
+            Data {
+                name = "a"
+                type = "b"
+            }
+            """)
+        try:
+            process_signature("users/user/test/d")
+            self.fail()
+        except NotAValidProcess:
+            pass
+
+        # Multiple with same name (and different type)
+        model_add("users/user/test/e", "formalisms/ProcessModel", """
+            Data {
+                name = "a"
+                type = "b"
+            }
+            Data {
+                name = "a"
+                type = "c"
+            }
+            """)
+        try:
+            process_signature("users/user/test/e")
+            self.fail()
+        except NotAValidProcess:
+            pass
+
+        # Try with something that is not even a process model
+        model_add("users/user/test/f", "formalisms/SimpleClassDiagrams", """
+            Class a {
+                name = "a"
+            }
+            """)
+        try:
+            process_signature("users/user/test/f")
+            self.fail()
+        except NotAProcess:
+            pass
+
     """
     def test_op_model_render(self):
     def test_op_process_signature(self):
+    def test_op_process_execute(self):
     """
 
     def test_modelling(self):

wrappers/classes/modelverse.xml

@@ -1392,6 +1392,20 @@
                         </raise>
                     </transition>
 
+                    <transition cond="self.expect_response_partial('Not a ProcessModel: ', pop=False)" target="../wait_for_action/history">
+                        <raise event="exception">
+                            <parameter expr="'NotAProcess'"/>
+                            <parameter expr="self.split_response(self.responses.pop(0))[0]"/>
+                        </raise>
+                    </transition>
+
+                    <transition cond="self.expect_response_partial('Not a valid ProcessModel: ', pop=False)" target="../wait_for_action/history">
+                        <raise event="exception">
+                            <parameter expr="'NotAValidProcess'"/>
+                            <parameter expr="self.split_response(self.responses.pop(0))[0]"/>
+                        </raise>
+                    </transition>
+
                     <transition cond="self.expect_response_partial('Model is not an operation: ', pop=False)" target="../wait_for_action/history">
                         <raise event="exception">
                             <parameter expr="'NotAnActivity'"/>

wrappers/modelverse.py

@@ -72,6 +72,12 @@ class NoSimpleClassDiagramsModel(ModelverseException):
 class NotAnActivity(ModelverseException):
     pass
 
+class NotAProcess(ModelverseException):
+    pass
+
+class NotAValidProcess(ModelverseException):
+    pass
+
 class UnknownAttribute(UnknownIdentifier):
     pass
 

wrappers/modelverse_SCCD.py

@@ -1938,6 +1938,16 @@ class Modelverse(RuntimeClassBase):
         _initialized_behaviour_operations_36.setTrigger(None)
         _initialized_behaviour_operations_36.setGuard(self._initialized_behaviour_operations_36_guard)
         self.states["/initialized/behaviour/operations"].addTransition(_initialized_behaviour_operations_36)
+        _initialized_behaviour_operations_37 = Transition(self, self.states["/initialized/behaviour/operations"], [self.states["/initialized/behaviour/wait_for_action/history"]])
+        _initialized_behaviour_operations_37.setAction(self._initialized_behaviour_operations_37_exec)
+        _initialized_behaviour_operations_37.setTrigger(None)
+        _initialized_behaviour_operations_37.setGuard(self._initialized_behaviour_operations_37_guard)
+        self.states["/initialized/behaviour/operations"].addTransition(_initialized_behaviour_operations_37)
+        _initialized_behaviour_operations_38 = Transition(self, self.states["/initialized/behaviour/operations"], [self.states["/initialized/behaviour/wait_for_action/history"]])
+        _initialized_behaviour_operations_38.setAction(self._initialized_behaviour_operations_38_exec)
+        _initialized_behaviour_operations_38.setTrigger(None)
+        _initialized_behaviour_operations_38.setGuard(self._initialized_behaviour_operations_38_guard)
+        self.states["/initialized/behaviour/operations"].addTransition(_initialized_behaviour_operations_38)
         
         # transition /initialized/behaviour/operations/store_on_scripted/transformation_add
         _initialized_behaviour_operations_store_on_scripted_transformation_add_0 = Transition(self, self.states["/initialized/behaviour/operations/store_on_scripted/transformation_add"], [self.states["/initialized/behaviour/wait_for_action/megamodelling"]])
@@ -2329,220 +2339,232 @@ class Modelverse(RuntimeClassBase):
         return self.expect_response_partial('Compilation error: ', pop=False)
     
     def _initialized_behaviour_operations_1_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['NotAnActivity', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['NotAProcess', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_1_guard(self, parameters):
-        return self.expect_response_partial('Model is not an operation: ', pop=False)
+        return self.expect_response_partial('Not a ProcessModel: ', pop=False)
     
     def _initialized_behaviour_operations_2_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ManualActivityRequiresIO', 'Manual activities require at least one input or output metamodel to be specified in order to create a meaningful metamodel.']))
+        self.raiseInternalEvent(Event("exception", None, ['NotAValidProcess', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_2_guard(self, parameters):
-        return self.expect_response_partial('Manual activity needs at least one formalism in its input or output signature', pop=True)
+        return self.expect_response_partial('Not a valid ProcessModel: ', pop=False)
     
     def _initialized_behaviour_operations_3_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['SourceModelNotBound', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['NotAnActivity', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_3_guard(self, parameters):
-        return self.expect_response_partial('Source model not bound: ', pop=False)
+        return self.expect_response_partial('Model is not an operation: ', pop=False)
     
     def _initialized_behaviour_operations_4_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['TargetModelNotBound', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['ManualActivityRequiresIO', 'Manual activities require at least one input or output metamodel to be specified in order to create a meaningful metamodel.']))
     
     def _initialized_behaviour_operations_4_guard(self, parameters):
-        return self.expect_response_partial('Target model not bound: ', pop=False)
+        return self.expect_response_partial('Manual activity needs at least one formalism in its input or output signature', pop=True)
     
     def _initialized_behaviour_operations_5_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['DifferingModelsForKey', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['SourceModelNotBound', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_5_guard(self, parameters):
-        return self.expect_response_partial('Input and output signature differ for same key: ', pop=False)
+        return self.expect_response_partial('Source model not bound: ', pop=False)
     
     def _initialized_behaviour_operations_6_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['IncorrectFormat', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['TargetModelNotBound', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_6_guard(self, parameters):
-        return self.expect_response_partial('Incorrect format: ', pop=False)
+        return self.expect_response_partial('Target model not bound: ', pop=False)
     
     def _initialized_behaviour_operations_7_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['NotAModel', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['DifferingModelsForKey', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_7_guard(self, parameters):
-        return self.expect_response_partial('Not a model: ', pop=False)
+        return self.expect_response_partial('Input and output signature differ for same key: ', pop=False)
     
     def _initialized_behaviour_operations_8_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownAttribute', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['IncorrectFormat', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_8_guard(self, parameters):
-        return self.expect_response_partial('Attribute not found: ', pop=False)
+        return self.expect_response_partial('Incorrect format: ', pop=False)
     
     def _initialized_behaviour_operations_9_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['SuperclassAttribute', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['NotAModel', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_9_guard(self, parameters):
-        return self.expect_response_partial('Attribute not defined here: ', pop=False)
+        return self.expect_response_partial('Not a model: ', pop=False)
     
     def _initialized_behaviour_operations_10_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownLocation', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownAttribute', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_10_guard(self, parameters):
-        return self.expect_response_partial('Unknown location: ', pop=False)
+        return self.expect_response_partial('Attribute not found: ', pop=False)
     
     def _initialized_behaviour_operations_11_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownGroup', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['SuperclassAttribute', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_11_guard(self, parameters):
-        return self.expect_response_partial('Unknown group: ', pop=False)
+        return self.expect_response_partial('Attribute not defined here: ', pop=False)
     
     def _initialized_behaviour_operations_12_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownUser', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownLocation', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_12_guard(self, parameters):
-        return self.expect_response_partial('Unknown user: ', pop=False)
+        return self.expect_response_partial('Unknown location: ', pop=False)
     
     def _initialized_behaviour_operations_13_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['NotAnAssociation', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownGroup', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_13_guard(self, parameters):
-        return self.expect_response_partial('Not an association: ', pop=False)
+        return self.expect_response_partial('Unknown group: ', pop=False)
     
     def _initialized_behaviour_operations_14_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UserExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownUser', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_14_guard(self, parameters):
-        return self.expect_response_partial('User exists: ', pop=False)
+        return self.expect_response_partial('Unknown user: ', pop=False)
     
     def _initialized_behaviour_operations_15_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ModelExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['NotAnAssociation', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_15_guard(self, parameters):
-        return self.expect_response_partial('Model exists: ', pop=False)
+        return self.expect_response_partial('Not an association: ', pop=False)
     
     def _initialized_behaviour_operations_16_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['GroupExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UserExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_16_guard(self, parameters):
-        return self.expect_response_partial('Group exists: ', pop=False)
+        return self.expect_response_partial('User exists: ', pop=False)
     
     def _initialized_behaviour_operations_17_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['FolderExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['ModelExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_17_guard(self, parameters):
-        return self.expect_response_partial('Folder exists: ', pop=False)
+        return self.expect_response_partial('Model exists: ', pop=False)
     
     def _initialized_behaviour_operations_18_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['AttributeExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['GroupExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_18_guard(self, parameters):
-        return self.expect_response_partial('Attribute exists: ', pop=False)
+        return self.expect_response_partial('Group exists: ', pop=False)
     
     def _initialized_behaviour_operations_19_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownM3', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['FolderExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_19_guard(self, parameters):
-        return self.expect_response_partial('Type cannot be typed as formalisms/SimpleClassDiagrams: ', pop=False)
+        return self.expect_response_partial('Folder exists: ', pop=False)
     
     def _initialized_behaviour_operations_20_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ElementExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['AttributeExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_20_guard(self, parameters):
-        return self.expect_response_partial('Element exists: ', pop=False)
+        return self.expect_response_partial('Attribute exists: ', pop=False)
     
     def _initialized_behaviour_operations_21_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ReadPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownM3', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_21_guard(self, parameters):
-        return self.expect_response_partial('Read permission denied to: ', pop=False)
+        return self.expect_response_partial('Type cannot be typed as formalisms/SimpleClassDiagrams: ', pop=False)
     
     def _initialized_behaviour_operations_22_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['ElementExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_22_guard(self, parameters):
-        return self.expect_response_partial('Write permission denied to: ', pop=False)
+        return self.expect_response_partial('Element exists: ', pop=False)
     
     def _initialized_behaviour_operations_23_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.current_model]))
+        self.raiseInternalEvent(Event("exception", None, ['ReadPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_23_guard(self, parameters):
-        return self.expect_response('Write permission denied', pop=True)
+        return self.expect_response_partial('Read permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_24_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownM3', 'Model is not a Simple Class Diagrams model and has no notion of defined attributes']))
+        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_24_guard(self, parameters):
-        return self.expect_response_partial('Not a SimpleClassDiagrams model!', pop=True)
+        return self.expect_response_partial('Write permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_25_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['EmptySignature', 'Model transformation activity cannot have an empty signature!']))
+        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.current_model]))
     
     def _initialized_behaviour_operations_25_guard(self, parameters):
-        return self.expect_response_partial('Model transformation needs at least one formalism in its input or output signature!', pop=True)
+        return self.expect_response('Write permission denied', pop=True)
     
     def _initialized_behaviour_operations_26_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ExecutePermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownM3', 'Model is not a Simple Class Diagrams model and has no notion of defined attributes']))
     
     def _initialized_behaviour_operations_26_guard(self, parameters):
-        return self.expect_response_partial('Execute permission denied to: ', pop=False)
+        return self.expect_response_partial('Not a SimpleClassDiagrams model!', pop=True)
     
     def _initialized_behaviour_operations_27_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['GroupPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['EmptySignature', 'Model transformation activity cannot have an empty signature!']))
     
     def _initialized_behaviour_operations_27_guard(self, parameters):
-        return self.expect_response_partial('Group permission denied to: ', pop=False)
+        return self.expect_response_partial('Model transformation needs at least one formalism in its input or output signature!', pop=True)
     
     def _initialized_behaviour_operations_28_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UserPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['ExecutePermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_28_guard(self, parameters):
-        return self.expect_response_partial('User permission denied to: ', pop=False)
+        return self.expect_response_partial('Execute permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_29_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UserNotInGroup', '']))
+        self.raiseInternalEvent(Event("exception", None, ['GroupPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_29_guard(self, parameters):
-        return self.expect_response_partial('User is not a member of the group!', pop=True)
+        return self.expect_response_partial('Group permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_30_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['AdminPermissionDenied', 'Admin permissions are required for this operation!']))
+        self.raiseInternalEvent(Event("exception", None, ['UserPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_30_guard(self, parameters):
-        return self.expect_response_partial('Admin permission denied', pop=True)
+        return self.expect_response_partial('User permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_31_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['InterfaceMismatch', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UserNotInGroup', '']))
     
     def _initialized_behaviour_operations_31_guard(self, parameters):
-        return self.expect_response_partial('Incorrect format: ', pop=False)
+        return self.expect_response_partial('User is not a member of the group!', pop=True)
     
     def _initialized_behaviour_operations_32_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownElement', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['AdminPermissionDenied', 'Admin permissions are required for this operation!']))
     
     def _initialized_behaviour_operations_32_guard(self, parameters):
-        return self.expect_response_partial('Element not found: ', pop=False)
+        return self.expect_response_partial('Admin permission denied', pop=True)
     
     def _initialized_behaviour_operations_33_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownModel', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['InterfaceMismatch', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_33_guard(self, parameters):
-        return self.expect_response_partial('Model not found: ', pop=False)
+        return self.expect_response_partial('Incorrect format: ', pop=False)
     
     def _initialized_behaviour_operations_34_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownMetamodellingHierarchy', 'Metamodelling hierarchy could not be resolved or automatically inferred: there is no typing relation between your specified model and metamodel (%s)' % self.responses.pop(0)]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownElement', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_34_guard(self, parameters):
-        return self.expect_response_partial('Conformance hierarchy unknown for: ', pop=False)
+        return self.expect_response_partial('Element not found: ', pop=False)
     
     def _initialized_behaviour_operations_35_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['TypeMismatch', self.responses.pop(0)]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownModel', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_35_guard(self, parameters):
-        return self.expect_response_partial('Signature mismatch in operation for tag: ', pop=False)
+        return self.expect_response_partial('Model not found: ', pop=False)
     
     def _initialized_behaviour_operations_36_exec(self, parameters):
+        self.raiseInternalEvent(Event("exception", None, ['UnknownMetamodellingHierarchy', 'Metamodelling hierarchy could not be resolved or automatically inferred: there is no typing relation between your specified model and metamodel (%s)' % self.responses.pop(0)]))
+    
+    def _initialized_behaviour_operations_36_guard(self, parameters):
+        return self.expect_response_partial('Conformance hierarchy unknown for: ', pop=False)
+    
+    def _initialized_behaviour_operations_37_exec(self, parameters):
+        self.raiseInternalEvent(Event("exception", None, ['TypeMismatch', self.responses.pop(0)]))
+    
+    def _initialized_behaviour_operations_37_guard(self, parameters):
+        return self.expect_response_partial('Signature mismatch in operation for tag: ', pop=False)
+    
+    def _initialized_behaviour_operations_38_exec(self, parameters):
         print("Unknown Error: " + self.responses[0])
         self.raiseInternalEvent(Event("exception", None, ['UnknownError', 'Error: %s' % self.responses.pop(0)]))
     
-    def _initialized_behaviour_operations_36_guard(self, parameters):
+    def _initialized_behaviour_operations_38_guard(self, parameters):
         return self.expect_response_partial('', pop=False)
     
     def _initialized_behaviour_operations_store_on_scripted_transformation_add_0_exec(self, parameters):