Check for signature mismatch when creating AL or manual activity

bootstrap/core_algorithm.alc

@@ -1794,6 +1794,10 @@ String function transformation_add(source_models : Element, target_models : Elem
 		if (model_id != ""):
 			if (allow_read(current_user_id, model_id)):
 				if (bool_not(dict_in(target, key))):
+					if (dict_in(source, key)):
+						if (value_neq(source[key], model_id)):
+							return "Input and output signature differ for same key: " + key!
+
 					dict_add(target, key, model_id)
 					mm = get_full_model(model_id, get_entry_id("formalisms/SimpleClassDiagrams"))
 					if (element_eq(mm, read_root())):
@@ -1941,13 +1945,7 @@ String function cmd_transformation_add_MT(source_models : Element, target_models
 								dict_add(target, key, model_id)
 								// Don't add to to_ramify, as it is already in there!
 							else:
-								return "Name in output cannot have different type than input: " + key!
-						else:
-							dict_add(target, key, model_id)
-							mm = get_full_model(model_id, get_entry_id("formalisms/SimpleClassDiagrams"))
-							if (element_eq(mm, read_root())):
-								return "Type cannot be typed as formalisms/SimpleClassDiagrams: " + name!
-							set_add_node(to_ramify, create_tuple(key, mm))
+								return "Input and output signature differ for same key: " + key!
 					else:
 						return "Name was already assigned a metamodel: " + key!
 				else:

unit/test_all.py

@@ -3818,12 +3818,48 @@ class TestModelverse(unittest.TestCase):
         def operation(model):
             # Check if both are present
             lst = element_list_nice(model)
-            print(lst)
+            assert len(lst) == 6
+            assert {"__id": "MODEL_A/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
+            assert {"__id": "MODEL_A/A", "__type": "Class", "name": "A", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
+            assert {"__id": "MODEL_A/A_name", "__type": "AttributeLink", "__source": "MODEL_A/A", "__target": "MODEL_A/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
+            assert {"__id": "MODEL_B/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
+            assert {"__id": "MODEL_B/B", "__type": "Class", "name": "B", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
+            assert {"__id": "MODEL_B/B_name", "__type": "AttributeLink", "__source": "MODEL_B/B", "__target": "MODEL_B/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
 
             # Do minor merge operation
-            instantiate(model, "Association", edge=("MODEL_A/A", "MODEL_B/B"))
+            instantiate(model, "Association", edge=("MODEL_A/A", "MODEL_B/B"), ID="trace")
+
+            # Check again
+            lst = element_list_nice(model)
+            assert len(lst) == 7
+            assert {"__id": "MODEL_A/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
+            assert {"__id": "MODEL_A/A", "__type": "Class", "name": "A", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
+            assert {"__id": "MODEL_A/A_name", "__type": "AttributeLink", "__source": "MODEL_A/A", "__target": "MODEL_A/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
+            assert {"__id": "MODEL_B/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
+            assert {"__id": "MODEL_B/B", "__type": "Class", "name": "B", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
+            assert {"__id": "MODEL_B/B_name", "__type": "AttributeLink", "__source": "MODEL_B/B", "__target": "MODEL_B/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
+            assert {"__id": "trace", "__type": "Association", "__source": "MODEL_A/A", "__target": "MODEL_B/B", "name": None, "source_lower_cardinality": None, "source_upper_cardinality": None, "target_lower_cardinality": None, "target_upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}, "lower_cardinality": None, "upper_cardinality": None} in lst
 
         transformation_add_MANUAL({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/d", operation)
+        
+        def operation(model):
+            # Check if both are present
+            lst = element_list_nice(model)
+            assert len(lst) == 6
+            assert {"__id": "MODEL_A/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
+            assert {"__id": "MODEL_A/A", "__type": "Class", "name": "A", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
+            assert {"__id": "MODEL_A/A_name", "__type": "AttributeLink", "__source": "MODEL_A/A", "__target": "MODEL_A/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
+            assert {"__id": "MODEL_B/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
+            assert {"__id": "MODEL_B/B", "__type": "Class", "name": "B", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
+            assert {"__id": "MODEL_B/B_name", "__type": "AttributeLink", "__source": "MODEL_B/B", "__target": "MODEL_B/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
+
+        transformation_add_MANUAL({"MODEL_A": "users/user/test/A", "MODEL_B": "users/user/test/B"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/e", operation)
+
+        try:
+            transformation_add_MANUAL({"MODEL_A": "users/user/test/A", "MODEL_B": "users/user/test/B"}, {"MODEL_B": "users/user/test/A"}, "users/user/test/f")
+            self.fail()
+        except SignatureMismatch:
+            pass
 
         # Add a transformation with empty signature
         transformation_add_MANUAL({}, {}, "users/user/test/g")

wrappers/classes/modelverse.xml

@@ -1392,6 +1392,13 @@
                         </raise>
                     </transition>
 
+                    <transition cond="self.expect_response_partial('Input and output signature differ for same key: ', pop=False)" target="../wait_for_action/history">
+                        <raise event="exception">
+                            <parameter expr="'SignatureMismatch'"/>
+                            <parameter expr="self.split_response(self.responses.pop(0))[0]"/>
+                        </raise>
+                    </transition>
+
                     <transition cond="self.expect_response_partial('Incorrect format: ', pop=False)" target="../wait_for_action/history">
                         <raise event="exception">
                             <parameter expr="'IncorrectFormat'"/>

wrappers/modelverse.py

@@ -36,6 +36,9 @@ class UserNotInGroup(ModelverseException):
 class IncorrectFormat(ModelverseException):
     pass
 
+class SignatureMismatch(ModelverseException):
+    pass
+
 class UnknownError(ModelverseException):
     pass
 

wrappers/modelverse_SCCD.py

@@ -1888,6 +1888,11 @@ class Modelverse(RuntimeClassBase):
         _initialized_behaviour_operations_30.setTrigger(None)
         _initialized_behaviour_operations_30.setGuard(self._initialized_behaviour_operations_30_guard)
         self.states["/initialized/behaviour/operations"].addTransition(_initialized_behaviour_operations_30)
+        _initialized_behaviour_operations_31 = Transition(self, self.states["/initialized/behaviour/operations"], [self.states["/initialized/behaviour/wait_for_action/history"]])
+        _initialized_behaviour_operations_31.setAction(self._initialized_behaviour_operations_31_exec)
+        _initialized_behaviour_operations_31.setTrigger(None)
+        _initialized_behaviour_operations_31.setGuard(self._initialized_behaviour_operations_31_guard)
+        self.states["/initialized/behaviour/operations"].addTransition(_initialized_behaviour_operations_31)
         
         # 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"]])
@@ -2285,179 +2290,185 @@ class Modelverse(RuntimeClassBase):
         return self.expect_response_partial('Manual activity needs at least one formalism in its input or output signature', pop=True)
     
     def _initialized_behaviour_operations_2_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['IncorrectFormat', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['SignatureMismatch', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_2_guard(self, parameters):
-        return self.expect_response_partial('Incorrect format: ', pop=False)
+        return self.expect_response_partial('Input and output signature differ for same key: ', pop=False)
     
     def _initialized_behaviour_operations_3_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['NotAModel', 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_3_guard(self, parameters):
-        return self.expect_response_partial('Not a model: ', pop=False)
+        return self.expect_response_partial('Incorrect format: ', pop=False)
     
     def _initialized_behaviour_operations_4_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownAttribute', 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_4_guard(self, parameters):
-        return self.expect_response_partial('Attribute not found: ', pop=False)
+        return self.expect_response_partial('Not a model: ', pop=False)
     
     def _initialized_behaviour_operations_5_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['SuperclassAttribute', 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_5_guard(self, parameters):
-        return self.expect_response_partial('Attribute not defined here: ', pop=False)
+        return self.expect_response_partial('Attribute not found: ', pop=False)
     
     def _initialized_behaviour_operations_6_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownLocation', 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_6_guard(self, parameters):
-        return self.expect_response_partial('Unknown location: ', pop=False)
+        return self.expect_response_partial('Attribute not defined here: ', pop=False)
     
     def _initialized_behaviour_operations_7_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownGroup', 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_7_guard(self, parameters):
-        return self.expect_response_partial('Unknown group: ', pop=False)
+        return self.expect_response_partial('Unknown location: ', pop=False)
     
     def _initialized_behaviour_operations_8_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownUser', 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_8_guard(self, parameters):
-        return self.expect_response_partial('Unknown user: ', pop=False)
+        return self.expect_response_partial('Unknown group: ', pop=False)
     
     def _initialized_behaviour_operations_9_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['NotAnAssociation', 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_9_guard(self, parameters):
-        return self.expect_response_partial('Not an association: ', pop=False)
+        return self.expect_response_partial('Unknown user: ', pop=False)
     
     def _initialized_behaviour_operations_10_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UserExists', 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_10_guard(self, parameters):
-        return self.expect_response_partial('User exists: ', pop=False)
+        return self.expect_response_partial('Not an association: ', pop=False)
     
     def _initialized_behaviour_operations_11_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ModelExists', 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_11_guard(self, parameters):
-        return self.expect_response_partial('Model exists: ', pop=False)
+        return self.expect_response_partial('User exists: ', pop=False)
     
     def _initialized_behaviour_operations_12_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['GroupExists', 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_12_guard(self, parameters):
-        return self.expect_response_partial('Group exists: ', pop=False)
+        return self.expect_response_partial('Model exists: ', pop=False)
     
     def _initialized_behaviour_operations_13_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['FolderExists', 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_13_guard(self, parameters):
-        return self.expect_response_partial('Folder exists: ', pop=False)
+        return self.expect_response_partial('Group exists: ', pop=False)
     
     def _initialized_behaviour_operations_14_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['AttributeExists', 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_14_guard(self, parameters):
-        return self.expect_response_partial('Attribute exists: ', pop=False)
+        return self.expect_response_partial('Folder exists: ', pop=False)
     
     def _initialized_behaviour_operations_15_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownM3', 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_15_guard(self, parameters):
-        return self.expect_response_partial('Type cannot be typed as formalisms/SimpleClassDiagrams: ', pop=False)
+        return self.expect_response_partial('Attribute exists: ', pop=False)
     
     def _initialized_behaviour_operations_16_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ElementExists', 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_16_guard(self, parameters):
-        return self.expect_response_partial('Element exists: ', pop=False)
+        return self.expect_response_partial('Type cannot be typed as formalisms/SimpleClassDiagrams: ', pop=False)
     
     def _initialized_behaviour_operations_17_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ReadPermissionDenied', 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_17_guard(self, parameters):
-        return self.expect_response_partial('Read permission denied to: ', pop=False)
+        return self.expect_response_partial('Element exists: ', pop=False)
     
     def _initialized_behaviour_operations_18_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['ReadPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_18_guard(self, parameters):
-        return self.expect_response_partial('Write permission denied to: ', pop=False)
+        return self.expect_response_partial('Read permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_19_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.current_model]))
+        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_19_guard(self, parameters):
-        return self.expect_response('Write permission denied', pop=True)
+        return self.expect_response_partial('Write permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_20_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['NoSimpleClassDiagramsModel', 'Model is not a Simple Class Diagrams model and has no notion of defined attributes']))
+        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.current_model]))
     
     def _initialized_behaviour_operations_20_guard(self, parameters):
-        return self.expect_response_partial('Not a SimpleClassDiagrams model!', pop=True)
+        return self.expect_response('Write permission denied', pop=True)
     
     def _initialized_behaviour_operations_21_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ExecutePermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['NoSimpleClassDiagramsModel', 'Model is not a Simple Class Diagrams model and has no notion of defined attributes']))
     
     def _initialized_behaviour_operations_21_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_22_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['GroupPermissionDenied', 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_22_guard(self, parameters):
-        return self.expect_response_partial('Group permission denied to: ', pop=False)
+        return self.expect_response_partial('Execute permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_23_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UserPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['GroupPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_23_guard(self, parameters):
-        return self.expect_response_partial('User permission denied to: ', pop=False)
+        return self.expect_response_partial('Group permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_24_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UserNotInGroup', '']))
+        self.raiseInternalEvent(Event("exception", None, ['UserPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_24_guard(self, parameters):
-        return self.expect_response_partial('User is not a member of the group!', pop=True)
+        return self.expect_response_partial('User permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_25_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['AdminPermissionDenied', 'Admin permissions are required for this operation!']))
+        self.raiseInternalEvent(Event("exception", None, ['UserNotInGroup', '']))
     
     def _initialized_behaviour_operations_25_guard(self, parameters):
-        return self.expect_response_partial('Admin permission denied', pop=True)
+        return self.expect_response_partial('User is not a member of the group!', pop=True)
     
     def _initialized_behaviour_operations_26_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['InterfaceMismatch', 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_26_guard(self, parameters):
-        return self.expect_response_partial('Incorrect format: ', pop=False)
+        return self.expect_response_partial('Admin permission denied', pop=True)
     
     def _initialized_behaviour_operations_27_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownElement', 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_27_guard(self, parameters):
-        return self.expect_response_partial('Element not found: ', pop=False)
+        return self.expect_response_partial('Incorrect format: ', pop=False)
     
     def _initialized_behaviour_operations_28_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownModel', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownElement', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_28_guard(self, parameters):
-        return self.expect_response_partial('Model not found: ', pop=False)
+        return self.expect_response_partial('Element not found: ', pop=False)
     
     def _initialized_behaviour_operations_29_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, ['UnknownModel', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_29_guard(self, parameters):
-        return self.expect_response_partial('Conformance hierarchy unknown for: ', pop=False)
+        return self.expect_response_partial('Model not found: ', pop=False)
     
     def _initialized_behaviour_operations_30_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_30_guard(self, parameters):
+        return self.expect_response_partial('Conformance hierarchy unknown for: ', pop=False)
+    
+    def _initialized_behaviour_operations_31_exec(self, parameters):
         print("Unknown Error: " + self.responses[0])
         pass
         self.raiseInternalEvent(Event("exception", None, ['UnknownError', 'Error: %s' % self.responses.pop(0)]))
     
-    def _initialized_behaviour_operations_30_guard(self, parameters):
+    def _initialized_behaviour_operations_31_guard(self, parameters):
         return self.expect_response_partial('', pop=False)
     
     def _initialized_behaviour_operations_store_on_scripted_transformation_add_0_exec(self, parameters):