From 766f2f1d2dd8eff31b1cc1fd9a9011d29bea3aab Mon Sep 17 00:00:00 2001
From: Philip Makedonski <makedonski@informatik.uni-goettingen.de>
Date: Thu, 6 Apr 2023 17:10:34 +0200
Subject: [PATCH] + updated manifest
+ temporary copies of ocl constraints
---
.../org.etsi.mts.tdl.constraints/.classpath | 1 +
.../META-INF/MANIFEST.MF | 3 +-
.../ocl/tdl-configurations-constraints.ocl | 29 +
.../ocl/tdl-constraints.ocl | 1153 +++++++++++++++++
.../ocl/tdl-structured-constraints.ocl | 134 ++
5 files changed, 1319 insertions(+), 1 deletion(-)
create mode 100644 plugins/org.etsi.mts.tdl.constraints/ocl/tdl-configurations-constraints.ocl
create mode 100644 plugins/org.etsi.mts.tdl.constraints/ocl/tdl-constraints.ocl
create mode 100644 plugins/org.etsi.mts.tdl.constraints/ocl/tdl-structured-constraints.ocl
diff --git a/plugins/org.etsi.mts.tdl.constraints/.classpath b/plugins/org.etsi.mts.tdl.constraints/.classpath
index 78b29bbf..8d82e860 100644
--- a/plugins/org.etsi.mts.tdl.constraints/.classpath
+++ b/plugins/org.etsi.mts.tdl.constraints/.classpath
@@ -4,5 +4,6 @@
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" path="epsilon"/>
+ <classpathentry kind="src" path="ocl"/>
<classpathentry kind="output" path="bin"/>
</classpath>
diff --git a/plugins/org.etsi.mts.tdl.constraints/META-INF/MANIFEST.MF b/plugins/org.etsi.mts.tdl.constraints/META-INF/MANIFEST.MF
index 632e0328..eb7b8317 100644
--- a/plugins/org.etsi.mts.tdl.constraints/META-INF/MANIFEST.MF
+++ b/plugins/org.etsi.mts.tdl.constraints/META-INF/MANIFEST.MF
@@ -18,5 +18,6 @@ Require-Bundle: org.eclipse.emf.common,
org.eclipse.emf.ecore.xmi,
org.etsi.mts.tdl.model,
org.eclipse.xtext,
- org.eclipse.epsilon.common.dt
+ org.eclipse.epsilon.common.dt,
+ org.eclipse.ocl.xtext.completeocl
Export-Package: org.etsi.mts.tdl.constraints.evl
diff --git a/plugins/org.etsi.mts.tdl.constraints/ocl/tdl-configurations-constraints.ocl b/plugins/org.etsi.mts.tdl.constraints/ocl/tdl-configurations-constraints.ocl
new file mode 100644
index 00000000..89e3e40e
--- /dev/null
+++ b/plugins/org.etsi.mts.tdl.constraints/ocl/tdl-configurations-constraints.ocl
@@ -0,0 +1,29 @@
+import 'http://www.etsi.org/spec/TDL/1.4.1'
+import 'http://www.etsi.org/spec/TDL/1.3.1/configurations'
+
+package extendedconfigurations
+
+context ComponentMerge
+ -- No self-merging
+ inv NoSelfMerge ('A \'ComponentInstance\' shall not be merged with itself, i.e. the source and target \'ComponentInstance\'s specified by means of the \'ComponentReference\'s shall be different. ' + self.toString()):
+ not (self.component.component = self.target.component and
+ self.component.configuration = self.target.configuration)
+
+
+ -- Conforming 'ComponentType's
+ inv ComponentMergeType ('The \'ComponentInstance\' specified by means of the target \'ComponentReference\'s shall have a \'ComponentType\' which conforms to the \'ComponentType\' of the source \'ComponentReference\'. ' + self.toString()):
+ self.target.component.type.conformsTo(self.component.component.type)
+
+
+
+
+context ComponentAlias
+ -- Mandatory name
+ inv AliasMandatoryName ('The \'name\' property of the \'ComponentAlias\' shall be set and it shall not be an empty String.' + self.toString()):
+ not self.name.oclIsUndefined() and self.name.size() > 0
+
+
+
+
+
+endpackage
diff --git a/plugins/org.etsi.mts.tdl.constraints/ocl/tdl-constraints.ocl b/plugins/org.etsi.mts.tdl.constraints/ocl/tdl-constraints.ocl
new file mode 100644
index 00000000..fda95c80
--- /dev/null
+++ b/plugins/org.etsi.mts.tdl.constraints/ocl/tdl-constraints.ocl
@@ -0,0 +1,1153 @@
+import 'http://www.etsi.org/spec/TDL/1.4.1'
+
+package tdl
+
+context NamedElement
+ -- Mandatory name
+ inv MandatoryName ('A \'NamedElement\' shall have the \'name\' property set and the \'name\' shall be not an empty String.' + self.toString()):
+ not self.name.oclIsUndefined() and self.name.size() > 0
+
+
+ -- Distinguishable qualified names
+ inv DistinquishableName ('All qualified names of instances of \'NamedElement\'s shall be distinguishable within a TDL model.' + self.toString()):
+ NamedElement.allInstances()->one(e | e.qualifiedName = self.qualifiedName)
+
+
+ -- [NOTE: It is up to the concrete syntax definition and tooling to resolve any name clashes between instances of the same meta-class in the qualified name.]
+
+
+context Package
+ -- No cyclic imports
+ inv CyclicImports ('A \'Package\' shall not import itself directly or indirectly.' + self.toString()):
+ self.import->asOrderedSet()->closure(i | i.importedPackage.import)->forAll(i |
+ i.importedPackage <> self)
+
+
+
+
+context ElementImport
+ -- Consistency of imported elements
+ inv ConsistentImports ('All imported \'PackageableElement\'s referenced by an \'ElementImport\' shall be directly owned by the imported \'Package\'.' + self.toString()):
+ self.importedElement->forAll(e | self.importedPackage.packagedElement->includes(e))
+
+
+ -- [Figure 5.2: Miscellaneous elements]
+
+
+context Comment
+ -- No nested comments
+ inv CommentNestedComments ('A \'Comment\' shall not contain \'Comment\'s.' + self.toString()):
+ self.comment->isEmpty()
+
+
+ -- No annotations to comments
+ inv CommentNestedAnnotations ('A \'Comment\' shall not contain \'Annotation\'s.' + self.toString()):
+ self.annotation->isEmpty()
+
+
+
+
+context Annotation
+ -- No nested annotations
+ inv AnnotationNestedAnnotations ('An \'Annotation\' shall not contain \'Annotation\'s' + self.toString()):
+ self.annotation->isEmpty()
+
+
+ -- No comments to annotations
+ inv AnnotationNestedComments ('An \'Annotation\' shall not contain \'Comment\'s.' + self.toString()):
+ self.comment->isEmpty()
+
+
+
+
+context Extension
+ -- Inherit from element of the same meta-class
+ inv Extension ('The element containing an \'Extension\' and the element in the \'extending\' property shall have the same meta-class.' + self.toString()):
+ self.container().oclType() = self.extending.oclType()
+
+
+
+
+context Constraint
+ -- Effectively static quantifiers
+ inv StaticQuantifiers ('All \'DataUse\'s specified as \'quantifier\'s shall be effectively static.' + self.toString()):
+ self.quantifier->forAll(q | q.isEffectivelyStatic())
+
+
+ -- Empty arguments for quantifiers
+ inv NoArgumentQuantifiers ('The \'argument\' sets for all \'DataUse\'s specified as \'quantifier\'s shall be empty.' + self.toString()):
+ self.quantifier->forAll(q | q.argument->isEmpty())
+
+
+ -- Constraint applicability for 'union' and 'uniontype'
+ inv ConstraintApplicabilityUnionUniontype ('The predefined \'ConstraintType\'s \'union\' and \'uniontype\' shall be applied to \'StructuredDataType\'s only. ' + self.toString()):
+ (self.type.name = 'union' or self.type.name = 'uniontype')
+ implies self.container().oclIsTypeOf(StructuredDataType)
+
+
+ -- Constraint applicability for 'range' and 'format'
+ inv ConstraintApplicabilityRangeFormat ('The predefined \'ConstraintType\'s \'range\' and \'format\' shall be applied to \'SimpleDataType\'s and \'Member\'s with a \'SimpleDataType\' \'dataType\' only. ' + self.toString()):
+ (self.type.name = 'range' or self.type.name = 'format')
+ implies (self.container().oclIsTypeOf(SimpleDataType)
+ or (self.container().oclIsTypeOf(Member)
+ and self.container().oclAsType(Member).dataType.oclIsTypeOf(SimpleDataType)))
+
+
+ -- Constraint applicability for 'length', 'minLength', and 'maxLength'
+ inv ConstraintApplicabilityLength ('The predefined \'ConstraintType\'s \'length\', \'minLength\', and \'maxLength\' shall be applied to \'CollectionDataType\'s, \'SimpleDataType\'s and \'Member\'s with a \'SimpleDataType\' or a \'CollectionDataType\' \'dataType\' only. ' + self.toString()):
+ (self.type.name = 'length' or self.type.name = 'minLength' or self.type.name = 'maxLength')
+ implies (self.container().oclIsTypeOf(SimpleDataType)
+ or self.container().oclIsTypeOf(CollectionDataType)
+ or (self.container().oclIsTypeOf(Member)
+ and self.container().oclAsType(Member).dataType.oclIsTypeOf(SimpleDataType))
+ and self.container().oclAsType(Member).dataType.oclIsTypeOf(CollectionDataType))
+
+
+ -- Quantifiers for 'length', 'minLength', and 'maxLength'
+ inv ConstraintQuantifierLength ('The predefined \'ConstraintType\'s \'length\', \'minLength\', and \'maxLength\' shall be used with exactly one \'quantifier\' resolved to an instance conforming to the predefined \'Integer\' \'DataType\'. ' + self.toString()):
+ (self.type.name = 'length' or self.type.name = 'minLength' or self.type.name = 'maxLength')
+ implies (self.quantifier->size() = 1
+ and self.quantifier->forAll(q | q.resolveDataType().conformsTo('Integer')))
+
+
+ -- Quantifiers for 'range'
+ inv ConstraintQuantifierRange ('The predefined \'ConstraintType\' \'range\' shall be used with exactly two \'quantifier\'s resolved to instance conforming to the predefined \'Integer\' \'DataType\'. ' + self.toString()):
+ (self.type.name = 'length')
+ implies (self.quantifier->size() = 2
+ and self.quantifier->forAll(q | q.resolveDataType().conformsTo('Integer')))
+
+
+
+
+context DataElementMapping
+ -- Restricted use of 'ParameterMapping'
+ inv ParameterMappingType ('A set of \'ParameterMapping\'s may only be provided if \'mappableDataElement\' refers to a \'StructuredDataType\', an \'Action\' or a \'Function\' definition and the \'mappableDataElement\' contains the mapped \'Parameters\'.' + self.toString()):
+ self.parameterMapping->size() = 0
+ or (self.mappableDataElement.oclIsTypeOf(StructuredDataType)
+ and self.parameterMapping->forAll(p |
+ self.mappableDataElement.oclAsType(StructuredDataType).allMembers()->includes(p.parameter)))
+ or (self.mappableDataElement.oclIsKindOf(Action)
+ and self.parameterMapping->forAll(p |
+ self.mappableDataElement.oclAsType(Action).formalParameter->includes(p.parameter)))
+
+
+ -- All parameters shall be mapped
+ inv ParameterMappings ('If the \'mappableDataElement\' refers to a \'StructuredDataType\', an \'Action\' or a \'Function\' definition, all the \'Parameters\' contained in the \'mappableDataElement\' shall be mapped.' + self.toString()):
+ (self.mappableDataElement.oclIsTypeOf(SimpleDataType)
+ or (self.mappableDataElement.oclIsTypeOf(StructuredDataType)
+ and self.mappableDataElement.oclAsType(StructuredDataType).member->forAll(p |
+ self.parameterMapping->exists(m | m.parameter = p)))
+ or (self.mappableDataElement.oclIsKindOf(Action)
+ and self.mappableDataElement.oclAsType(Action).formalParameter->forAll(p |
+ self.parameterMapping->exists(m | m.parameter = p)))
+ and self.parameterMapping->forAll(p |
+ self.mappableDataElement.oclAsType(Action).formalParameter->includes(p.parameter)))
+
+
+
+
+context SimpleDataInstance
+ -- SimpleDataInstance shall refer to SimpleDataType
+ inv SimpleDataInstanceType ('The inherited reference \'dataType\' from \'DataInstance\' shall refer to instances of \'SimpleDataType\' solely.' + self.toString()):
+ self.dataType.oclIsKindOf(SimpleDataType)
+
+
+ -- [Figure 6.3: Structured data type and instance]
+
+
+context StructuredDataType
+ -- Different member names in a structured data type
+ inv DistinguishableMemberNames ('All \'Member\' names of a \'StructuredDataType\' (including the names of inherited \'Members\') shall be distinguishable.' + self.toString()):
+ self.allMembers()->isUnique(e | e.name)
+
+
+
+
+context StructuredDataInstance
+ -- StructuredDataInstance shall refer to StructuredDataType
+ inv StructuredDataInstance ('The inherited reference \'dataType\' from \'DataInstance\' shall refer to instances of \'StructuredDataType\' solely.' + self.toString()):
+ self.dataType.oclIsTypeOf(StructuredDataType)
+
+
+ -- 'Member' of the 'StructuredDataType'
+ inv ExistingMemberOfDataType ('The referenced \'Member\' shall be contained in or inherited by the \'StructuredDataType\' that the \'StructuredDataInstance\', which contains this \'MemberAssignment\', refers to.' + self.toString()):
+ self.memberAssignment->forAll(a | self.dataType.oclAsType(StructuredDataType).allMembers()->includes(a.member))
+
+
+ -- Unique assignments for each 'Member' of the 'StructuredDataType'
+ inv UniqueMemberAssignments ('There shall be at most one \'memberAssignment\' for each \'Member\' of the \'StructuredDataType\' that the \'StructuredDataInstance\', which contains this \'MemberAssignment\', refers to.' + self.toString()):
+ self.memberAssignment->isUnique(m | m.member)
+
+
+ -- 'union' constraint on the type of the 'StructuredDataInstance'
+ inv StructuredDataInstanceUnionConstraint ('If the \'dataType\' of the \'StructuredDataInstance\' has the predefined constraint \'union\' then the \'memberAssignment\' shall not contain more than one \'MemberAssignment\'.' + self.toString()):
+ not self.dataType.allConstraints()->exists(c | c.type.name = 'union')
+ or self.memberAssignment->size() <= 1
+
+
+ -- 'uniontype' constraint on the type of the 'StructuredDataInstance'
+ inv StructuredDataInstanceUniontypeConstraint ('If the \'dataType\' of \'StructuredDataInstance\' has the predefined constraint \'uniontype\' then there shall only be \'MemberAssignment\' for the \'Member\'s of the \'dataType\' itself or of at most one of the \'StructuredDataType\'s which the \'dataType\' is extending.' + self.toString()):
+ not self.dataType.allConstraints()->exists(c | c.type.name = 'uniontype')
+ or self.memberAssignment->forAll(m | self.dataType.oclAsType(StructuredDataType).member->includes(m)
+ or self.dataType.oclAsType(StructuredDataType).extension->one(e |
+ e.extending.oclAsType(StructuredDataType).allMembers()->includes(m)))
+
+
+
+
+context MemberAssignment
+ -- Type of a 'memberSpec' shall conform to the type of the 'member'
+ inv MatchingMemberDataType ('The \'DataType\' of the \'DataUse\' of \'memberSpec\' shall conform to the \'DataType\' of the \'Member\' of the \'MemberAssignment\'.' + self.toString()):
+ self.memberSpec.resolveDataType().conformsTo(self.member.dataType)
+
+
+ -- Restricted use of 'OmitValue' for optional 'Member's only
+ inv OmitValueUse ('A non-optional \'Member\' shall have a \'DataUse\' specification assigned to it that is different from \'OmitValue\' and \'AnyValueOrOmit\'.' + self.toString()):
+ (self.memberSpec.oclIsTypeOf(OmitValue) or self.memberSpec.oclIsTypeOf(AnyValueOrOmit))
+ implies self.member.isOptional = true
+
+
+ -- Static data use in 'memberSpec'
+ inv StaticDataInMemberSpec ('The \'memberSpec\' and all of its \'ParameterBinding\'s shall be effectively static. ' + self.toString()):
+ self.memberSpec.isEffectivelyStatic()
+
+
+ -- [Figure 6.4: Collection data]
+
+
+context CollectionDataType
+ -- No multidimensional collections
+ inv NoMultidimensionalCollections ('The \'itemType\' shall not be an instance of \'CollectionDataType\'. ' + self.toString()):
+ not self.itemType.oclIsKindOf(CollectionDataType)
+
+
+
+
+context CollectionDataInstance
+ -- CollectionDataInstance shall refer to CollectionDataType
+ inv CollectionDataInstanceType ('The inherited reference \'dataType\' from \'DataInstance\' shall refer to instances of \'CollectionDataType\' solely.' + self.toString()):
+ self.dataType.oclIsKindOf(CollectionDataType)
+
+
+ -- Type of items in the 'CollectionDataInstance'
+ inv CollectionDataInstanceItemType ('The items in \'CollectionDataInstance\' shall conform to the \'itemType\' of the \'CollectionDataType\' that is defined as the \'dataType\' of this \'CollectionDataInstance\'. ' + self.toString()):
+ self.item->forAll(i |
+ i.resolveDataType().conformsTo(self.dataType.oclAsType(CollectionDataType).itemType))
+
+
+ -- Static data use in 'item'
+ inv StaticDataInItem ('The DataUse\'s in \'item\' and all of the respective \'ParameterBinding\'s shall be effectively static. ' + self.toString()):
+ self.item->forAll(i | i.isEffectivelyStatic())
+
+
+ -- Length constraint of the 'CollectionDataInstance'
+ inv CollectionDataInstanceLengthConstraint ('If the \'dataType\' \'CollectionType\' contains the predefined constraint \'length\' then the length of this \'CollectionDataInstance\' shall be equal to the \'quantifier\' of that \'Constraint\'.' + self.toString()):
+ true --This constraint cannot be expressed formally.
+
+
+ -- [Figure 6.5: Procedure and procedure parameter]
+
+
+context EnumDataType
+ -- SimpleDataInstance container in EnumDataType
+ inv EnumDataInstanceContainment ('A \'SimpleDataInstance\' whose \'dataType\' property refers to an \'EnumDataType\' shall be contained in that \'EnumDataType\'.' + self.toString()):
+ OclInvalid
+
+
+ -- No extensions for EnumDataType
+ inv EnumDataTypeExtensions ('The \'extension\' property of an \'EnumDataType\' shall be empty.' + self.toString()):
+ OclInvalid
+
+
+
+
+context DataUse
+ -- Occurrence of 'argument' and 'reduction'
+ inv ArgumentReductionLists ('Only in case of a \'FunctionCall\' both the \'argument\' list and the \'reduction\' list may be provided, otherwise either the \'argument\' list, the \'reduction\' list, or none of them shall be provided.' + self.toString()):
+ self.argument->isEmpty() or self.reduction->isEmpty() or self.oclIsTypeOf(FunctionCall)
+
+
+ -- Structured data types in 'reduction' set
+ inv ReductionMembers ('The \'Member\' referenced by the \'MemberReference\' at index i of a \'reduction\' shall be contained in or inherited by the \'StructuredDataType\' of the \'Member\' referenced by the \'MemberReference\' at index (i - 1) of that \'reduction\'.' + self.toString()):
+ not self.resolveDataType().oclIsKindOf(StructuredDataType)
+ or self.reduction->isEmpty()
+ or self.resolveDataType().oclAsType(StructuredDataType).allMembers()->includes(self.reduction->first().member)
+ and self.reduction->select(m | self.reduction->indexOf(m) > 0)->forAll(m |
+ self.reduction->at(self.reduction->indexOf(m)-1).member.dataType.oclIsKindOf(StructuredDataType)
+ and self.reduction->at(self.reduction->indexOf(m)-1).member.dataType.oclAsType(StructuredDataType).allMembers()
+ ->includes(m.member))
+
+
+ -- No member with collection index in the first element in reduction
+ inv FirstReduction ('The first \'MemberReference\' in reduction shall not specify both member and collectionIndex. ' + self.toString()):
+ self.reduction->first().member.oclIsUndefined() or self.reduction->first().collectionIndex.oclIsUndefined()
+
+
+
+
+context ParameterBinding
+ -- Matching data type
+ inv ParameterBindingTypes ('The provided \'DataUse\' shall conform to the \'DataType\' of the referenced \'Parameter\'.' + self.toString()):
+ self.dataUse.resolveDataType().conformsTo(self.parameter.dataType)
+
+
+ -- Use of a 'StructuredDataInstance' with non-optional 'Member's
+ inv OmitValueParameter ('A non-optional \'Member\' of a \'StructuredDataType\' shall have a \'DataUse\' specification assigned to it that is different from \'OmitValue\' or \'AnyValueOrOmit\'.' + self.toString()):
+ self.parameter.oclIsTypeOf(Member) and self.parameter.oclAsType(Member).isOptional = false
+ implies not self.dataUse.oclIsTypeOf(OmitValue) and not self.dataUse.oclIsTypeOf(AnyValueOrOmit)
+
+
+
+
+context MemberReference
+ -- Collection index expressions for collections only
+ inv CollectionIndex ('If the type of the related \'DataUse\' is not \'CollectionDataType\' then the collectionIndex shall be undefined. ' + self.toString()):
+ self.collectionIndex.oclIsUndefined()
+ or self.container().oclAsType(DataUse).resolveDataType().oclIsKindOf(CollectionDataType)
+
+
+ -- Either member or collection index is required
+ inv MemberOrReduction ('Either the member or collectionIndex shall be specified. ' + self.toString()):
+ not self.member.oclIsUndefined() or not self.collectionIndex.oclIsUndefined()
+
+
+
+
+context DataInstanceUse
+ -- 'DataInstance' reference or non-empty 'argument' or non-empty 'item'
+ inv DataInstanceOrArgumentsOrItems ('If a \'dataInstance\' is not specified, either a non-empty \'argument\' set or a non-empty \'item\' set shall be specified.' + self.toString()):
+ not self.dataInstance.oclIsUndefined() or not self.argument->isEmpty() or not self.item->isEmpty()
+
+
+ -- Valid 'DataType' for items
+ inv DataTypeOfItemsInDataInstance ('The items in the \'item\' property shall conform to the \'itemType\' of the resolved \'CollectionDataType\'.' + self.toString()):
+ self.item->forAll(i | i.resolveDataType().conformsTo(self.resolveDataType().oclAsType(CollectionDataType).itemType))
+
+
+ -- No 'item' if 'dataInstance' is specified
+ inv NoItemWithDataInstance ('The \'item\' property shall be empty if the \'dataInstance\' property is specified.' + self.toString()):
+ not self.dataInstance.oclIsUndefined() and self.item->isEmpty()
+
+
+
+
+context SpecialValueUse
+ -- Empty 'argument' and 'reduction' sets
+ inv SpecialValueArgumentReduction ('The \'argument\' and \'reduction\' sets shall be empty.' + self.toString()):
+ self.reduction->isEmpty() and self.argument->isEmpty()
+
+
+
+
+context FunctionCall
+ -- Matching parameters
+ inv FunctionCallParameters ('All \'FormalParameter\'s of the invoked \'Function\' shall be bound.' + self.toString()):
+ self.function.formalParameter->forAll(p | self.argument->exists(a | a.parameter = p))
+
+
+
+
+context VariableUse
+ -- Local variables of tester components only
+ inv VariableUseComponentRole ('All variables used in a \'DataUse\' specification via a \'VariableUse\' shall be local to the same \'componentInstance\' and the \'componentInstance\' shall be in the role \'Tester\'.' + self.toString()):
+ self.componentInstance.type.allVariables()->includes(self.variable)
+ and self.componentInstance.role = ComponentInstanceRole::Tester
+
+
+
+
+context PredefinedFunctionCall
+ -- Compatible actual parameters
+ inv PredefinedFunctionCallParameters ('The number and type of actual parameters shall be compatible with the formal parameters of the invoked \'PredefinedFunction\' according to the specification of the \'PredefinedFunction\'.' + self.toString()):
+ true --This constraint cannot be expressed formally.
+
+
+ -- Empty 'argument' and 'reduction' sets
+ inv PredefinedFunctionCallArgumentReduction ('The \'argument\' and \'reduction\' sets shall be empty.' + self.toString()):
+ self.reduction->isEmpty() and self.argument->isEmpty()
+
+
+
+
+context LiteralValueUse
+ -- Exactly one value specification
+ inv SpecifiedLiteralValue ('There shall be exactly one value specification, where either the \'value\', or the \'intValue\', or the \'boolValue\' property is be specified, but not more than one of them.' + self.toString()):
+ not self.value.oclIsUndefined()
+ xor not self.intValue.oclIsUndefined()
+ xor not self.boolValue.oclIsUndefined()
+
+
+ -- Empty 'argument' and 'reduction' sets if not 'dataType'
+ inv LiteralValueArgumentReduction ('If \'dataType\' is not specified then the \'argument\' and \'reduction\' sets shall be empty.' + self.toString()):
+ (self.dataType.oclIsUndefined())
+ implies (self.reduction->isEmpty() and self.argument->isEmpty())
+
+
+ -- Integer type for integer value
+ inv LiteralValueIntType ('If \'intValue\' is specified then the \'dataType\' is either unspecified or the specified \'DataType\' conforms to predefined type \'Integer\'.' + self.toString()):
+ not self.intValue.oclIsUndefined()
+ implies (self.dataType.oclIsUndefined() or self.dataType.conformsTo('Integer'))
+
+
+ -- Boolean type for Boolean value
+ inv LiteralValueBoolType ('If \'boolValue\' is specified then the \'dataType\' is either unspecified or the specified \'DataType\' conforms to predefined type \'Boolean\'.' + self.toString()):
+ not self.boolValue.oclIsUndefined()
+ implies (self.dataType.oclIsUndefined() or self.dataType.conformsTo('Boolean'))
+
+
+
+
+context DataElementUse
+ -- 'DataElement' reference or non-empty 'argument' or non-empty 'item'
+ inv DataInstanceOrArgumentsOrItemsInDataElementUse ('If a \'dataElement\' is not specified, or if the \'dataElement\' is resolved to a \'StructuredDataType\' or a \'CollectionDataType\', either a non-empty \'argument\' set or a non-empty \'item\' set shall be specified.' + self.toString()):
+ not (self.dataElement.oclIsUndefined() and self.argument->isEmpty() and self.item->isEmpty())
+ and not (self.dataElement.oclIsKindOf(StructuredDataType) and self.argument->isEmpty())
+ and not (self.dataElement.oclIsKindOf(CollectionDataType) and self.item->isEmpty())
+
+
+ -- Valid 'DataType' for items
+ inv DataTypeOfItemsInDataInstance ('The items in the \'item\' property shall conform to the \'itemType\' of the resolved \'CollectionDataType\'.' + self.toString()):
+ self.item->forAll(i | i.resolveDataType().conformsTo(self.resolveDataType().oclAsType(CollectionDataType).itemType))
+
+
+ -- Only 'item' if the resolved data type is 'CollectionDataType'
+ inv ItemOnlyWithCollectionDataType ('The \'item\' property shall be non-empty if the \'dataElement\' property is resolved to a \'CollectionDataType\'.' + self.toString()):
+ (((self.dataElement.oclIsKindOf(CollectionDataType))
+ or self.dataElement.oclIsUndefined())
+ and not self.item->isEmpty())
+ or self.item->isEmpty()
+
+
+ -- Matching parameters for 'Function's
+ inv FunctionCallParameters ('All \'FormalParameter\'s shall be bound if the \'dataElement\' refers to a \'Function\'.' + self.toString()):
+ not self.dataElement.oclIsKindOf(Function)
+ or self.dataElement.oclAsType(Function).formalParameter->forAll(p | self.argument->exists(a | a.parameter = p))
+
+
+
+
+context TimeLabelUse
+ -- Empty 'argument' and 'reduction' sets
+ inv TimeLabelArgumentReduction ('The \'argument\' and \'reduction\' sets shall be empty.' + self.toString()):
+ self.reduction->isEmpty() and self.argument->isEmpty()
+
+
+ -- 'TimeLabel's only within the same 'TestDescription' when local ordering is used
+ inv TimeLabelLocallyOrdered ('When local ordering is used, \'TimeLabel\'s shall only be used within the same test description. ' + self.toString()):
+ self.getParentTestDescription().isLocallyOrdered = true
+ or self.timeLabel.getParentTestDescription() = self.getParentTestDescription()
+
+
+
+
+context TimeConstraint
+ -- Time constraint expression of type Boolean
+ inv TimeConstraintType ('The expression given in the \'DataUse\' specification shall evaluate to predefined type \'Boolean\'.' + self.toString()):
+ self.timeConstraintExpression.resolveDataType().name = 'Boolean'
+
+
+ -- Use of local variables only
+ inv TimeConstraintVariables ('The expression given in the \'DataUse\' specification shall contain only \'Variable\'s that are local to the \'AtomicBehaviour\' that contains this \'TimeConstraint\'. That is, all \'VariableUse\'s shall reference the \'ComponentInstance\'s which participate in the \'AtomicBehaviour\'.' + self.toString()):
+ self.timeConstraintExpression.argument
+ ->closure(a | a.dataUse.argument)->collect(pb | pb.dataUse)
+ ->union(self.timeConstraintExpression.argument)
+ ->select(du | du.oclIsKindOf(VariableUse))
+ ->forAll(du | self.container().oclAsType(Behaviour).getParticipatingComponents()->includes(
+ du.oclAsType(VariableUse).componentInstance))
+
+
+ -- Use of local time labels only
+ inv TimeConstraintTimeLabels ('In case of locally ordered \'TestDescription\', the expression given in the \'DataUse\' specification shall contain only \'TimeLabel\'s that are local to the \'AtomicBehaviour\' that contains this \'TimeConstraint\'. That is, all \'TimeLabel\'s shall be contained in \'AtomicBehaviour\'s involving the \'ComponentInstance\'s which participate in the \'AtomicBehaviour\' that contains this \'TimeConstraint.' + self.toString()):
+ self.timeConstraintExpression.argument
+ ->closure(a | a.dataUse.argument)->collect(pb | pb.dataUse)
+ ->union(self.timeConstraintExpression.argument)
+ ->select(du | du.oclIsKindOf(TimeLabelUse))
+ ->forAll(du | self.container().oclAsType(Behaviour).getParticipatingComponents()->includesAll(
+ du.oclAsType(TimeLabelUse).timeLabel.container().oclAsType(Behaviour).getParticipatingComponents()))
+
+
+ -- [Figure 7.2: Time operations]
+
+
+context TimeOperation
+ -- Component required in locally ordered test description
+ inv TimeOperationComponent ('If the \'TimeOperation\' is contained in a locally ordered \'TestDescription\' then the \'componentInstance\' shall be specified.' + self.toString()):
+ self.getParentTestDescription().isLocallyOrdered
+ implies not self.componentInstance.oclIsUndefined()
+
+
+ -- Time operations on tester components only
+ inv TimeOperationComponentRole ('A \'TimeOperation\' shall be performed only on a \'ComponentInstance\' in the role \'Tester\'.' + self.toString()):
+ (not self.componentInstance.oclIsUndefined()
+ and self.componentInstance.role = ComponentInstanceRole::Tester)
+ or (self.oclIsTypeOf(Quiescence)
+ and not self.oclAsType(Quiescence).gateReference.oclIsUndefined()
+ and self.oclAsType(Quiescence).gateReference.component.role = ComponentInstanceRole::Tester)
+
+
+ -- 'Time' data type for period expression
+ inv TimePeriodType ('The \'DataUse\' expression assigned to the \'period\' shall evaluate to a data instance of the \'Time\' data type.' + self.toString()):
+ self.period.resolveDataType().oclIsKindOf(Time)
+
+
+
+
+context Quiescence
+ -- Exclusive use of gate reference or component instance
+ inv QuiescenceTarget ('If a \'GateReference\' is provided, a \'ComponentInstance\' shall not be provided and vice versa.' + self.toString()):
+ self.gateReference.oclIsUndefined() xor self.componentInstance.oclIsUndefined()
+
+
+ -- [Figure 7.3: Timer and timer operations]
+
+
+context TimerOperation
+ -- Timer operations on tester components only
+ inv TimerOperationComponentRole ('A \'TimerOperation\' shall be performed only on a \'ComponentInstance\' in the role \'Tester\'.' + self.toString()):
+ self.componentInstance.role = ComponentInstanceRole::Tester
+
+
+
+
+context TimerStart
+ -- 'Time' data type for period expression
+ inv TimerPeriodType ('The \'DataUse\' expression assigned to the \'period\' shall evaluate to a data instance of the \'Time\' data type.' + self.toString()):
+ self.period.resolveDataType().oclIsKindOf(Time)
+
+
+
+
+context GateType
+ -- Compatible 'DataType's.
+ inv GateType ('The \'DateType\'s specified for the \'GateType\' shall correspond the kind of the \'GateType\'. For \'GateType\' of kind \'Procedure\' only \'ProcedureSignature\'s shall be specified as data types. For \'GateType\' of kind \'Message\' only \'StructuredDataType\'s, \'SimpleDataType\'s and \'CollectionDataType\'s shall be specified as data types. ' + self.toString()):
+ (self.kind = GateTypeKind::Procedure and self.allDataTypes()->forAll(t |
+ t.oclIsTypeOf(ProcedureSignature)))
+ or (self.kind = GateTypeKind::Message and self.allDataTypes()->forAll(t | t.oclIsTypeOf(StructuredDataType)
+ or t.oclIsKindOf(SimpleDataType) or t.oclIsTypeOf(CollectionDataType)))
+
+
+
+
+context GateReference
+ -- Gate instance of the referred component instance
+ inv GateInstanceReference ('The referred \'GateInstance\' shall be contained in the \'ComponentType\' of the referred \'ComponentInstance\'.' + self.toString()):
+ self.component.type.allGates()->includes(self.gate)
+
+
+
+
+context Connection
+ -- Self-loop connections are not permitted
+ inv NoSelfLoop ('The \'endPoint\'s of a \'Connection\' shall not be the same. Two endpoints are the same if both, the referred \'ComponentInstance\'s and the referred \'GateInstance\'s, are identical.' + self.toString()):
+ self.endPoint->forAll(e1 | self.endPoint->one(e2 | e1.gate = e2.gate
+ and e1.component = e2.component))
+
+
+ -- Consistent type of a connection
+ inv ConsistentConnectionType ('The \'GateInstance\'s of the two \'endPoint\'s of a \'Connection\' shall refer to the same \'GateType\'.' + self.toString()):
+ self. endPoint.gate.type->asSet()->size() = 1
+
+
+
+
+context TestConfiguration
+ -- 'TestConfiguration' and components roles
+ inv ComponentRoles ('A \'TestConfiguration\' shall contain at least one \'Tester\' and one \'SUT\' \'ComponentInstance\'.' + self.toString()):
+ self.componentInstance->exists(c | c.role = ComponentInstanceRole::Tester)
+ and self.componentInstance->exists(c | c.role = ComponentInstanceRole::SUT)
+
+
+ -- Only 'Connection's between own 'ComponentInstance's
+ inv OwnedComponents ('A \'TestConfiguration\' shall only contain \'Connection\'s between gates of its own \'ComponentInstance\'s. ' + self.toString()):
+ self.connection->forAll(c |
+ self.componentInstance->includesAll(c.endPoint.component))
+
+
+ -- Minimal 'TestConfiguration'
+ inv MinimalTestConfiguration ('Each \'TestConfiguration\' shall specify at least one \'Connection\' that connects a \'GateInstance\' of a \'ComponentInstance\' in the role \'Tester\' with a \'GateInstance\' of a \'ComponentInstance\' in the role \'SUT\'.' + self.toString()):
+ self.connection->exists(c |
+ c.endPoint.component.role->includesAll(Set{ComponentInstanceRole::SUT, ComponentInstanceRole::Tester}))
+
+
+ -- At most one connection between any two 'GateInstance'/'ComponentInstance' pairs
+ inv UniqueConnections ('Given the set of \'Connection\'s contained in a \'TestConfiguration\'. There shall be no two \'Connection\'s containing \'GateReference\'s that in turn refer to identical pairs of \'GateInstance\'/\'ComponentInstance\'.' + self.toString()):
+ self.connection->forAll(c1 | self.connection->one(c2 |
+ not c1.endPoint->reject(ep1 | not c2.endPoint->exists(ep2 |
+ ep1.component = ep2.component and ep1.gate = ep2.gate
+ ))->isEmpty()
+ ))
+
+
+
+
+context Block
+ -- Guard shall evaluate to Boolean
+ inv GuardType ('The type of \'guard\' shall be \'Boolean\'.' + self.toString()):
+ self.guard ->forAll(g | g.expression.resolveDataType().name = 'Boolean')
+
+
+ -- No directly contained 'ExceptionalBehaviour's and 'PeriodicBehaviour's.
+ inv AllowedBehaviourTypes ('A \'Block\' shall not contain \'ExceptionalBehaviour\'s and \'PeriodicBehaviour\'s.' + self.toString()):
+ self.behaviour->forAll(b |
+ not b.oclIsTypeOf(ExceptionalBehaviour) and not b.oclIsTypeOf(PeriodicBehaviour))
+
+
+ -- Guard for each participating tester in locally ordered test descriptions
+ inv GuardsForParticipatingComponents ('If the \'Block\' is contained in a locally ordered \'TestDescription\' then a guard shall be specified for every participating \'ComponentInstance\' in the associated \'TestConfiguration\' that has the role \'Tester\' or there shall be no guards at all. ' + self.toString()):
+ self.guard->size() = 0
+ or self.getParticipatingComponents()->reject(c | c.role = ComponentInstanceRole::SUT)
+ ->forAll(c | self.guard->exists(ex | ex.componentInstance = c))
+ or not self.getParentTestDescription().isLocallyOrdered
+
+
+ -- Single guard in totally ordered test description
+ inv SingleTotalGuard ('If the \'Block\' is contained in a totally ordered \'TestDescription\' then there shall not be more than one guard. ' + self.toString()):
+ self.getParentTestDescription().isLocallyOrdered or self.guard->size() <= 1
+
+
+
+
+context LocalExpression
+ -- Local expressions in locally ordered test descriptions have 'ComponentInstance' specified
+ inv LocalExpressionComponent ('If the \'LocalExpression\' is contained in a locally ordered \'TestDescription\' then the componentInstance shall be specified. ' + self.toString()):
+ self.getParentTestDescription().isLocallyOrdered
+ implies not self.componentInstance.oclIsUndefined()
+
+
+ -- Only local variables and time labels in case of locally ordered test description
+ inv LocalVariablesAndTimersInExpression ('If the componentInstance is specified then all \'Variable\'s and \'TimeLabel\'s used in the expression shall be local to that \'ComponentInstance\'.' + self.toString()):
+ self.expression.argument
+ ->closure(a | a.dataUse.argument)->collect(pb | pb.dataUse)
+ ->union(self.expression.argument)
+ ->including(self.expression)
+ ->select(du | du.oclIsKindOf(VariableUse))
+ ->forAll(du | du.oclAsType(VariableUse).componentInstance = self.componentInstance)
+ and self.expression.argument
+ ->closure(a | a.dataUse.argument)->collect(pb | pb.dataUse)
+ ->union(self.expression.argument)
+ ->including(self.expression)
+ ->select(du | du.oclIsKindOf(TimeLabelUse))
+ ->forAll(du | du.oclAsType(TimeLabelUse).timeLabel.container().oclAsType(Behaviour)
+ .getParticipatingComponents()->includes(self.componentInstance))
+
+
+
+
+context BoundedLoopBehaviour
+ -- No guard constraint
+ inv BoundedGuard ('The \'Block\' of a \'BoundedLoopBehaviour\' shall not have a \'guard\'.' + self.toString()):
+ self.block->forAll(b | b.guard.oclIsUndefined())
+
+
+ -- Iteration number shall be countable and positive
+ inv LoopIteration ('The expression assigned to the \'numIteration\' property shall evaluate to a countable \'SimpleDataInstance\' of an arbitrary user-defined data type, e.g. a positive Integer value.' + self.toString()):
+ self.numIteration->forAll(e | e.expression.resolveDataType().conformsTo('Integer'))
+
+
+ -- Iteration count in locally ordered test descriptions
+ inv IterationCountsForParticipatingComponents ('If the \'BoundedLoopBehaviour\' is contained in a locally ordered \'TestDescription\' then a numIteration shall be specified for every participating \'ComponentInstance\' that has the role \'Tester\'.' + self.toString()):
+ self.block.getParticipatingComponents()->reject(c | c.role = ComponentInstanceRole::SUT)
+ ->forAll(c | self.numIteration->exists(ex | ex.componentInstance = c))
+ or not self.getParentTestDescription().isLocallyOrdered
+
+
+ -- Single numIteration in totally ordered test description
+ inv SingleTotalIterationCount ('If the \'BoundedLoopBehaviour\' is contained in a totally ordered \'TestDescription\' then there shall be exactly one numIteration.' + self.toString()):
+ self.getParentTestDescription().isLocallyOrdered or self.numIteration->size() = 1
+
+
+
+
+context OptionalBehaviour
+ -- First 'AtomicBehaviour' in block allowed
+ inv OptionalBehaviourStart ('The block of an \'OptionalBehaviour\' shall start with a tester-to-tester \'Interaction\'. ' + self.toString()):
+ self.block.behaviour->first().oclIsKindOf(Interaction)
+ and self.block.behaviour->first().oclAsType(Interaction)
+ ->collect(i | i.sourceGate.component->union(i.target.targetGate.component))
+ ->forAll(c | c.role = ComponentInstanceRole::Tester)
+
+
+ -- No other testers except the participants of starting 'Interaction' within 'OptionalBehaviour' in locally ordered 'TestDescription'
+ inv OptionalBehaviourParticipation ('If an \'OptionalBehaviour\' is included in a locally ordered \'TestDescription\' then no other tester \'ComponentInstance\' shall participate in the block of the \'OptionalBehaviour\' than the source and target of the starting \'Interaction\' except when being a target of the starting \'Interaction\' in a nested \'OptionalBehaviour\'. ' + self.toString()):
+ let initial = self.block.behaviour->first().oclAsType(Interaction),
+ initialComponents = initial->collect(i | i.sourceGate.component->union(i.target.targetGate.component)),
+ optionals = self.block->closure(
+ b | b.behaviour
+ ->select(oclIsKindOf(SingleCombinedBehaviour)).oclAsType(SingleCombinedBehaviour).block
+ ->union(b.behaviour
+ ->select(oclIsKindOf(MultipleCombinedBehaviour)).oclAsType(MultipleCombinedBehaviour).block)
+ ).behaviour->select(oclIsKindOf(OptionalBehaviour)).oclAsType(OptionalBehaviour),
+ optionalTargets = optionals.block->select(b | b.behaviour->select(i | i.oclIsKindOf(Interaction))->first().oclAsType(Interaction).target.targetGate.component)
+ in
+ self.block.getParticipatingComponents()
+ ->forAll(c | initialComponents->includes(c) or optionalTargets->includes(c))
+ or not self.getParentTestDescription().isLocallyOrdered
+
+
+
+
+context AlternativeBehaviour
+ -- Number of 'Block's
+ inv AlternativeBlockCount ('An \'AlternativeBehaviour\' shall contain at least two \'Block\'s. ' + self.toString()):
+ self.block->size() > 1
+
+
+ -- First behaviour of 'Block's
+ inv FirstBlockBehaviour ('Each block of an \'AlternativeBehaviour\' shall start with a tester-input event. ' + self.toString()):
+ self.block->forAll(b | b.behaviour->first().isTesterInputEvent())
+
+
+ -- Same component if locally ordered
+ inv AlternativeBlocksComponent ('If the containing \'TestDescription\' is locally ordered then all \'Block\'s shall start with a tester-input event of the same \'ComponentInstance\'. ' + self.toString()):
+ let initial = self.block.behaviour->first() in
+ Set{}
+ ->including(initial->select(oclIsKindOf(Interaction)).oclAsType(Interaction).target.targetGate.component)
+ ->including(initial->select(oclIsKindOf(Quiescence)).oclAsType(Quiescence).componentInstance)
+ -> including(initial->select(oclIsKindOf(TimeOut)).oclAsType(TimeOut).componentInstance)
+ ->size() = 1 or not self.getParentTestDescription().isLocallyOrdered
+
+
+ -- Tester participating in locally ordered case
+ inv AlternativeBehaviourParticipation ('If the \'AlternativeBehaviour\' is contained in a locally ordered \'TestDescription\' then no other tester \'ComponentInstance\' shall participate in any block than the target of the first tester-input event and \'ComponentInstance\'s participating in blocks of contained \'OptionalBehaviour\'s. ' + self.toString()):
+ let initial = self.block.behaviour->first(),
+ targetComponent = Set{}
+ ->including(initial->select(oclIsKindOf(Interaction)).oclAsType(Interaction).target.targetGate.component)
+ ->including(initial->select(oclIsKindOf(Quiescence)).oclAsType(Quiescence).componentInstance)
+ -> including(initial->select(oclIsKindOf(TimeOut)).oclAsType(TimeOut).componentInstance),
+ nonOptionalBlocks = self.block->closure(
+ b | b.behaviour->reject(oclIsKindOf(OptionalBehaviour))
+ ->select(oclIsKindOf(SingleCombinedBehaviour)).oclAsType(SingleCombinedBehaviour).block
+ ->union(b.behaviour->reject(oclIsKindOf(OptionalBehaviour))
+ ->select(oclIsKindOf(MultipleCombinedBehaviour)).oclAsType(MultipleCombinedBehaviour).block)
+ )
+ in
+ targetComponent->includesAll(
+ nonOptionalBlocks.getParticipatingComponents()->reject(c | c.role = ComponentInstanceRole::SUT))
+ or not self.getParentTestDescription().isLocallyOrdered
+
+
+ -- OptionalBehaviour in locally ordered case
+ inv OptionalAlternativeBehaviour ('A block of an \'AlternativeBehaviour\' if the containing \'TestDescription\' is locally ordered, shall only contain \'OptionalBehaviour\'(s) whose source \'ComponentInstance\' is the same as the target of the first tester-input event of that \'Block\'. ' + self.toString()):
+ let initial = self.block.behaviour->first(),
+ targetComponent = Set{}
+ ->including(initial->select(oclIsKindOf(Interaction)).oclAsType(Interaction).target.targetGate.component)
+ ->including(initial->select(oclIsKindOf(Quiescence)).oclAsType(Quiescence).componentInstance)
+ -> including(initial->select(oclIsKindOf(TimeOut)).oclAsType(TimeOut).componentInstance)
+ in
+ self.block.behaviour->select(oclIsKindOf(OptionalBehaviour)) .oclAsType(OptionalBehaviour).block
+ ->first().oclAsType(Interaction).sourceGate.component->forAll(c | targetComponent->includes(c))
+ or not self.getParentTestDescription().isLocallyOrdered
+
+
+
+
+context ConditionalBehaviour
+ -- Guard for 'ConditionalBehaviour' with single block
+ inv ConditionalFirstGuard ('If there is only one \'Block\' specified, it shall have a \'guard\'.' + self.toString()):
+ self.block->size() > 1 or self.block->first().guard->size() > 1
+
+
+ -- Possible else block for 'ConditionalBehaviour' with multiple blocks
+ inv ConditionalLastGuard ('All \'Block\'s specified, except the last one, shall have a \'guard\'.' + self.toString()):
+ self.block->size() = 1
+ or self.block->forAll(b | b = self.block->last() or b.guard ->size() > 1)
+
+
+
+
+context ParallelBehaviour
+ -- Number of blocks in 'ParallelBehaviour'
+ inv ParallelBlockCount ('There shall be at least two \'Block\'s specified.' + self.toString()):
+ self.block->size() > 1
+
+
+ -- [Figure 9.3: Exceptional and periodic behaviour]
+
+
+context ExceptionalBehaviour
+ -- First 'AtomicBehaviour' in block allowed
+ inv FirstExceptionalBehaviour ('The block of an \'ExceptionalBehaviour\' shall start with a tester-input event.' + self.toString()):
+ self.block.behaviour->first().isTesterInputEvent()
+
+
+ -- Guarded component shall be a 'Tester' component
+ inv ExceptionalGuardedComponent ('The \'guardedComponent\' shall refer to a \'ComponentInstance\' with the role of \'Tester\'.' + self.toString()):
+ self.guardedComponent.oclIsUndefined() or self.guardedComponent.role = ComponentInstanceRole::Tester
+
+
+ -- Same component if locally ordered and guarded component present
+ inv ExceptionalGuardedandTargetComponent ('If the containing \'TestDescription\' is locally ordered and guardedComponent is specified then the \'Block\'s shall start with tester-input event of the same \'ComponentInstance\' as specified in guardedComponent. ' + self.toString()):
+ let initial = self.block.behaviour->first(),
+ targetComponent = Set{}
+ ->including(initial->select(oclIsKindOf(Interaction)).oclAsType(Interaction).target.targetGate.component)
+ ->including(initial->select(oclIsKindOf(Quiescence)).oclAsType(Quiescence).componentInstance)
+ -> including(initial->select(oclIsKindOf(TimeOut)).oclAsType(TimeOut).componentInstance)
+ in
+ guardedComponent->includesAll(targetComponent)
+ or not self.getParentTestDescription().isLocallyOrdered
+
+
+ -- Tester participating in locally ordered case
+ inv ExceptionalBehaviourParticipation ('If the \'ExceptionalBehaviour\' is contained in a locally ordered \'TestDescription\' then no other tester \'ComponentInstance\' shall participate in any block than the target of the first tester-input event and \'ComponentInstance\'s participating in blocks of contained \'OptionalBehaviour\'s . ' + self.toString()):
+ let initial = self.block.behaviour->first(),
+ targetComponent = Set{}
+ ->including(initial->select(oclIsKindOf(Interaction)).oclAsType(Interaction).target.targetGate.component)
+ ->including(initial->select(oclIsKindOf(Quiescence)).oclAsType(Quiescence).componentInstance)
+ -> including(initial->select(oclIsKindOf(TimeOut)).oclAsType(TimeOut).componentInstance),
+ nonOptionalBlocks = self.block->closure(
+ b | b.behaviour->reject(oclIsKindOf(OptionalBehaviour))
+ ->select(oclIsKindOf(SingleCombinedBehaviour)).oclAsType(SingleCombinedBehaviour).block
+ ->union(b.behaviour->reject(oclIsKindOf(OptionalBehaviour))
+ ->select(oclIsKindOf(MultipleCombinedBehaviour)).oclAsType(MultipleCombinedBehaviour).block)
+ )
+ in
+ targetComponent->includesAll(
+ nonOptionalBlocks.getParticipatingComponents()->reject(c | c.role = ComponentInstanceRole::SUT))
+ or not self.getParentTestDescription().isLocallyOrdered
+
+
+ -- OptionalBehaviour in locally ordered case
+ inv OptionalExceptionalBehaviour ('A block of an \'ExceptionalBehaviour\' if the containing \'TestDescription\' is locally ordered, shall only contain \'OptionalBehaviour\'(s) whose source \'ComponentInstance\' is the same as the target of the first tester-input event of that \'Block\'. ' + self.toString()):
+ let initial = self.block.behaviour->first(),
+ targetComponent = Set{}
+ ->including(initial->select(oclIsKindOf(Interaction)).oclAsType(Interaction).target.targetGate.component)
+ ->including(initial->select(oclIsKindOf(Quiescence)).oclAsType(Quiescence).componentInstance)
+ -> including(initial->select(oclIsKindOf(TimeOut)).oclAsType(TimeOut).componentInstance)
+ in
+ self.block.behaviour->select(oclIsKindOf(OptionalBehaviour)).oclAsType(OptionalBehaviour).block
+ ->first().oclAsType(Interaction).sourceGate.component->forAll(c | targetComponent->includes(c))
+ or not self.getParentTestDescription().isLocallyOrdered
+
+
+
+
+context PeriodicBehaviour
+ -- 'Time' data type for period expression
+ inv PeriodType ('The \'DataUse\' expression assigned to the \'period\' shall evaluate to a data instance of the \'Time\' data type.' + self.toString()):
+ self.period->forAll(e | e.expression.resolveDataType().oclIsKindOf(Time))
+
+
+ -- Period for each tester in locally ordered test descriptions
+ inv PeriodForParticipatingComponents ('If the \'PeriodicBehaviour\' is contained in a locally ordered \'TestDescription\' then a period shall be specified for every \'ComponentInstance\' that has the role \'Tester\' and for which there is a behaviour in the contained \'Block\'. ' + self.toString()):
+ self.block.getParticipatingComponents()->reject(c | c.role = ComponentInstanceRole::SUT)
+ ->forAll(c | self.period->exists(ex | ex.componentInstance = c))
+ or not self.getParentTestDescription().isLocallyOrdered
+
+
+
+
+context Break
+ -- Break in conditional behaviour only
+ inv ConditionalBreak ('A \'Break\' shall be contained directly in the block of a \'ConditionalBehaviour\'. ' + self.toString()):
+ self.container().container().oclIsKindOf(ConditionalBehaviour)
+
+
+ -- No behaviours after break
+ inv BreakIsLast ('A \'Break\' shall be the last behaviour in the containing \'Block\'. ' + self.toString()):
+ self.container().oclAsType(Block).behaviour->last() = self
+
+
+
+
+context VerdictAssignment
+ -- Verdict of type 'Verdict'
+ inv VerdictType ('The \'verdict\' shall evaluate to a, possibly predefined, instance of a \'SimpleDataInstance\' of data type \'Verdict\'.' + self.toString()):
+ self.verdict.resolveDataType().name = 'Verdict'
+
+
+ -- No 'SpecialValueUse'
+ inv VerdictNoSpecialValueUse ('The \'verdict\' shall not evaluate to an instance of a \'SpecialValueUse\'.' + self.toString()):
+ not self.verdict.oclIsKindOf(SpecialValueUse)
+
+
+
+
+context Assertion
+ -- Boolean condition
+ inv AssertionOtherwise ('The \'condition\' shall evaluate to predefined \'DataType\' \'Boolean\'.' + self.toString()):
+ self.condition.resolveDataType().name = 'Boolean'
+
+
+ -- Otherwise of type 'Verdict'
+ inv AssertionVerdict ('The \'otherwise\' shall evaluate to a, possibly predefined, instance of a \'SimpleDataInstance\' of data type \'Verdict\'.' + self.toString()):
+ self.otherwise.oclIsUndefined() or self.otherwise.resolveDataType().name = 'Verdict'
+
+
+ -- No 'SpecialValueUse'
+ inv AssertionNoSpecialValueUse ('The \'otherwise\' shall not evaluate to an instance of a \'SpecialValueUse\'.' + self.toString()):
+ not self.otherwise.oclIsKindOf(SpecialValueUse)
+
+
+ -- [Figure 9.5: Interaction behaviour]
+
+
+context Interaction
+ -- Gate references of an interaction shall be connected
+ inv ConnectedInteractionGates ('The \'GateReference\'s that act as source or target(s) of an \'Interaction\' shall be interconnected by a \'Connection\' which is contained in the \'TestConfiguration\' referenced by the \'TestDescription\' containing the \'Interaction\'.' + self.toString()):
+ self.target->forAll(t |
+ self.getParentTestDescription().testConfiguration.connection->exists(c |
+ not c.endPoint->reject(ep |
+ (ep.component = self.sourceGate.component and ep.gate = self.sourceGate.component) or
+ (ep.component = t.targetGate.component and ep.gate = t.targetGate.gate)
+ )->isEmpty()))
+
+
+
+
+context Message
+ -- 'DataType' resolvable
+ inv DataTypeResolvable ('If the \'argument\' is \'DataInstanceUse\', either the \'dataType\' property or the \'dataInstance\' property shall be provided. If the \'argument\' is a \'DataElementUse\', the \'dataElement\' property shall be provided.' + self.toString()):
+ not self.argument.oclIsUndefined()
+
+
+ -- Type of message argument
+ inv MessageArgumentAndGateType ('The \'DataUse\' specification referred to in the \'argument\' shall match one of the \'DataType\'s referenced in the \'GateType\' definition of the \'GateInstance\'s referred to by the source and target \'GateReference\'s of the \'Interaction\'.' + self.toString()):
+ (self.argument.oclIsKindOf(AnyValue)
+ and self.argument. resolveDataType().oclIsUndefined())
+ or (self.sourceGate.gate.type.allDataTypes()-> exists(t | self.argument.resolveDataType().conformsTo(t))
+ and self.target->forAll(t | t.targetGate.gate.type.allDataTypes()->exists(t | self.argument.resolveDataType().conformsTo(t))))
+
+
+ -- Use of variables in the 'argument' specification
+ inv MessageArgumentVariableUse ('The use of \'Variable\'s in the \'DataUse\' specification shall be restricted to \'Variable\'s of \'ComponentInstance\'s that participate in this \'Message\' via the provided \'GateReference\'s.' + self.toString()):
+ (not self.argument.oclIsKindOf(VariableUse)
+ or (self.sourceGate.component = self.argument.oclAsType(VariableUse).componentInstance
+ or self.target->exists(t |
+ t.targetGate.component = self.argument.oclAsType(VariableUse).componentInstance)))
+
+ and self.argument.argument->forAll(a |
+ not a.dataUse.oclIsKindOf(VariableUse)
+ or (self.sourceGate.component = a.dataUse.oclAsType(VariableUse).componentInstance
+ or self.target->exists(t |
+ t.targetGate.component = a.dataUse.oclAsType(VariableUse).componentInstance)))
+
+ and self.argument.argument->closure(a | a.dataUse.argument)->forAll(a |
+ not a.dataUse.oclIsKindOf(VariableUse)
+ or (self.sourceGate.component = a.dataUse.oclAsType(VariableUse).componentInstance
+ or self.target->exists(t |
+ t.targetGate.component = a.dataUse.oclAsType(VariableUse).componentInstance)))
+
+
+ -- Conforming data type for 'argument' and 'variable'
+ inv MessageArgumentAndVariableType ('If a \'Variable\' is specified for a \'Target\', the \'DataType\' of \'DataUse\' specification of the \'argument\' shall conform to the \'DataType\'s of referenced \'Variable\'s of all \'Target\'s.' + self.toString()):
+ self.target->forAll(t | t.valueAssignment->size() = 0
+ or not self.argument.resolveDataType().oclIsUndefined()
+ and t.valueAssignment->forAll(v | self.argument.resolveDataType().conformsTo(v.variable.dataType)))
+
+
+
+
+context ProcedureCall
+ -- Only point-to-point procedure calls
+ inv ProcedureCallTargetCount ('The \'target\' of \'ProcedureCall\' shall contain exactly one \'Target\'. ' + self.toString()):
+ self.target->size() = 1
+
+
+ -- Each call has a reply
+ inv ProcedureCallHasReply ('For every \'ProcedureCall\' with empty \'replyTo\' there shall be one or more \'ProcedureCall\'s that have this \'ProcedureCall\' as \'replyTo\'. ' + self.toString()):
+ ProcedureCall.allInstances()->exists(pc | pc.replyTo = self)
+
+
+ -- Call and reply within the same 'TestDescription'
+ inv ProcedureCallAndReply ('The \'ProcedureCall\' referenced in the \'replyTo\' shall be within the same \'TestDescription\' as this \'ProcedureCall\'. ' + self.toString()):
+ self.replyTo.oclIsUndefined()
+ or self.replyTo.getParentTestDescription() = self.getParentTestDescription()
+
+
+ -- Call and reply between same components
+ inv ProcedureCallReplyGates ('The \'sourceGate\' and \'target\' of a \'ProcedureCall\' with \'replyTo\' shall match the \'target\' and \'sourceGate\' of the \'ProcedureCall\' in the \'replyTo\'. That is, corresponding \'GateReference\'s shall be the equal. ' + self.toString()):
+ ProcedureCall.allInstances()->select(pc | pc.replyTo = self)->forAll(
+ reply |
+ reply.target->forAll(t | t.targetGate.component = self.sourceGate.component)
+ and reply.target->forAll(t | t.targetGate.gate = self.sourceGate.gate)
+ and self.target->forAll(t | t.targetGate.component = reply.sourceGate.component)
+ and self.target->forAll(t | t.targetGate.gate = reply.sourceGate.gate))
+
+
+ -- Synchronous procedure calls
+ inv ProcedureCallSynchronousCalling ('A \'ProcedureCall\' with empty \'replyTo\' shall not be followed by any behaviour in which the component specified in the \'sourceGate\' is participating, other than a \'ProcedureCall\' that specifies this \'ProcedureCall\' as \'replyTo\' or an \'AlternativeBehaviour\' that contains such a \'ProcedureCall\' in the beginning of a \'block\'. ' + self.toString()):
+ let source = self.sourceGate.component,
+ affectingBehaviours = self.container().oclAsType(Block).behaviour
+ ->reject(b | b.oclIsKindOf(ActionBehaviour)
+ and b.oclAsType(ActionBehaviour).componentInstance <> source)
+ ->reject(b | b.oclIsKindOf(Interaction)
+ and b.oclAsType(Interaction).sourceGate.component <> source
+ and b.oclAsType(Interaction).target->forAll(t | t.targetGate.component <> source))
+ ->reject(b| b.oclIsKindOf(TestDescriptionReference)
+ and (not b.oclAsType(TestDescriptionReference).componentInstanceBinding->isEmpty()
+ and not b.oclAsType(TestDescriptionReference).componentInstanceBinding
+ .actualComponent->includes(self))),
+ following = affectingBehaviours ->at(affectingBehaviours->indexOf(self) + 1)
+ in (following.oclIsKindOf(ProcedureCall) and following.oclAsType(ProcedureCall).replyTo = self)
+ or (following.oclIsKindOf(AlternativeBehaviour)
+ and following.oclAsType(AlternativeBehaviour).block->exists(
+ b | b.behaviour->first().oclIsKindOf(ProcedureCall)
+ and b.behaviour->first().oclAsType(ProcedureCall).replyTo = self))
+
+
+ -- Type of procedure call
+ inv ProcedureCallSignatureInGateTypes ('The \'ProcedureSignature\' referred to in the \'procedure\' shall be one of the \'DataType\'s referenced in the \'GateType\' definition of the \'GateInstance\'s referred to by the source and target \'GateReference\'s of the \'ProcedureCall\'. ' + self.toString()):
+ self.sourceGate.gate.type.allDataTypes()->includes(self.signature)
+ and self.target->forAll(targetGate.gate.type.allDataTypes()->includes(self.signature))
+
+
+ -- No mixing of parameters
+ inv ProcedureParameterKind ('All \'ParameterBinding\'s specified in the \'argument\' shall refer to \'ProcedureParameter\'s of the same \'ParameterKind\'. ' + self.toString()):
+ self.argument->collect(pb | pb.parameter.oclAsType(ProcedureParameter).kind)
+ ->asSet()->size() <= 1
+
+
+ -- Matching procedure arguments
+ inv ProcedureCallArguments ('For a \'ProcedureCall\' with empty \'replyTo\' there shall be one \'ParameterBinding\' instance in the \'argument\' for each \'ProcedureParameter\' with kind \'In\' in the associated \'ProcedureSignature\'. For a \'ProcedureCall\' with \'replyTo\' there shall be one \'ParameterBinding\' instance in the \'argument\' for each \'ProcedureParameter\' with kind \'Out\' or \'Exception\' in the associated \'ProcedureSignature\'. ' + self.toString()):
+ (self.replyTo.oclIsUndefined() and self.signature.parameter->select(p | p.kind = ParameterKind::In)
+ ->forAll(p | self.argument.parameter->includes(p)))
+ or (not self.replyTo.oclIsUndefined() and self.signature.parameter->reject(p | p.kind = ParameterKind::In)
+ ->forAll(p | self.argument.parameter->includes(p)))
+
+
+ -- Use of variables in the 'argument' specification
+ inv ProcedureCallVariableUse ('The use of \'Variable\'s in the \'DataUse\' specifications in \'ParameterBinding\'s shall be restricted to \'Variable\'s of \'ComponentInstance\'s that participate in this \'ProcedureCall\' via the provided \'GateReference\'s. ' + self.toString()):
+ self.argument
+ ->closure(pb | pb.dataUse.argument)->union(self.argument)->collect(pb | pb.dataUse)
+ ->select(du | du.oclIsKindOf(VariableUse))
+ ->forAll(du | self.getParticipatingComponents()->includes(
+ du.oclAsType(VariableUse).componentInstance))
+
+
+ -- Reply not starting event of exceptional behaviour
+ inv ProcedureCallReplyNotInExceptional ('A \'ProcedureCall\' that specifies replyTo shall not be the first behaviour of a block in an \'ExceptionalBehaviour\'. ' + self.toString()):
+ self.replyTo.oclIsUndefined() or not self.container().container().oclIsKindOf(ExceptionalBehaviour)
+
+
+
+
+context Target
+ -- Variable and target gate of the same component instance
+ inv TargetComponent ('The \'Variable\'s referenced by \'valueAssignment\' shall exist in the same \'ComponentType\' as the \'GateInstance\' that is referred to by the \'GateReference\' of the \'targetGate\'.' + self.toString()):
+ self.valueAssignment->isEmpty()
+ or self.targetGate.component.type.allVariables()->includesAll(self.valueAssignment.variable)
+
+
+ -- Variable of a tester component only
+ inv TargetVariableComponentRole ('If a \'ValueAssignment\' is specified, the \'ComponentInstance\' referenced by \'targetGate\' shall be in the role \'Tester\'.' + self.toString()):
+ self.valueAssignment->isEmpty () or self.targetGate.component.role = ComponentInstanceRole::Tester
+
+
+
+
+context ValueAssignment
+ -- Conforming data type for 'parameter' and 'variable'
+ inv AssignedParamterType ('If the \'parameter\' is specified then its type shall conform to the type of the \'variable\'. ' + self.toString()):
+ self.parameter.oclIsUndefined() or self.parameter.dataType.conformsTo(self.variable.dataType)
+
+
+ -- Parameter of associated procedure signature
+ inv AssignedProcedureParameter ('If the \'parameter\' is specified then it shall be contained in the \'ProcedureSignature\' that is referred in the \'signature\' ot the \'ProcedureCall\' containing this \'ValueAssignment\'.' + self.toString()):
+ self.parameter.oclIsUndefined()
+ or (self.container().container().oclIsKindOf(ProcedureCall) and
+ self.container().container().oclAsType(ProcedureCall).signature.parameter->includes(self.parameter))
+
+
+ -- [Figure 9.6: Test description reference]
+
+
+context TestDescriptionReference
+ -- All test description parameters bound
+ inv AllTestDescriptionParametersBound ('For each \'FormalParameter\' defined in \'formalParameter of\' the referenced \'TestDescription\' there shall be a \'ParameterBinding\' in \'argument\' that refers to that \'FormalParameter\' in \'parameter\'.' + self.toString()):
+ self.testDescription.formalParameter->forAll(p | self.argument->exists(a | a.parameter = p))
+
+
+ -- No use of variables in arguments
+ inv NoVariablesInLocallyOrderedTestDescriptionReference ('In locally ordered \'TestDescription\'s, \'DataUse\' expressions used to describe arguments shall not contain variables directly or indirectly in \'TestDescriptionReference\'s.' + self.toString()):
+ self.argument. dataUse->forAll(du |
+ not du.oclIsKindOf(VariableUse)
+ and du.argument->forAll(a | not a.dataUse.oclIsKindOf(VariableUse))
+ and du.argument->closure(a | a.dataUse.argument)->forAll(a |
+ not a.dataUse.oclIsKindOf(VariableUse)))
+
+
+ -- No use of time labels in arguments
+ inv NoTimeLabelsInLocallyOrderedTestDescriptionReference ('In locally ordered \'TestDescription\'s, \'DataUse\' expressions used to describe arguments shall not contain time labels directly or indirectly in \'TestDescriptionReference\'s.' + self.toString()):
+ self.argument.dataUse->forAll(du |
+ not du.oclIsKindOf(TimeLabelUse)
+ and du.argument->forAll(a | not a.dataUse.oclIsKindOf(TimeLabelUse))
+ and du.argument->closure(a | a.dataUse.argument)->forAll(a |
+ not a.dataUse.oclIsKindOf(TimeLabelUse)))
+
+
+ -- Restriction to 1:1 component instance bindings
+ inv UniqueComponentBindings ('If component instance bindings are provided, the component instances referred to in the bindings shall occur at most once for the given test description reference.' + self.toString()):
+ self.componentInstanceBinding->isEmpty()
+ or self.componentInstanceBinding->forAll(b |
+ self.componentInstanceBinding->one(c |
+ c.formalComponent = b.formalComponent or c.actualComponent = b.actualComponent))
+
+
+ -- Compatible test configurations
+ inv CompatibleConfiguration ('The \'TestConfiguration\' of the referenced (invoked) \'TestDescription\' shall be compatible with the \'TestConfiguration\' of the referencing (invoking) \'TestDescription\' under the provided \'ComponentInstanceBinding\'s between the \'ComponentInstance\'s of the \'TestConfiguration\'s of referenced and referencing \'TestDescription\'s. ' + self.toString()):
+ self.testDescription.testConfiguration.compatibleWith(
+ self.getParentTestDescription().testConfiguration, self.componentInstanceBinding)
+
+
+ -- No combining of local and total ordering
+ inv LocalAndTotalOrdering ('The referenced \'TestDescription\' shall have the same ordering assumption as the referencing \'TestDescription\'.' + self.toString()):
+ self.getParentTestDescription().isLocallyOrdered = self.testDescription.isLocallyOrdered
+
+
+
+
+context ComponentInstanceBinding
+ -- Conforming component types
+ inv BindingComponentTypes ('The \'ComponentType\' of the actual \'ComponentInstance\' shall conform to \'ComponentType\' of the formal \'ComponentInstance.' + self.toString()):
+ self.actualComponent.type.conformsTo(self.formalComponent.type)
+
+
+ -- Matching component instance roles
+ inv BindingComponentRoles ('Both, the formal and the actual component instances, shall have the same \'ComponentInstanceRole\' assigned to.' + self.toString()):
+ self.formalComponent.role = self.actualComponent.role
+
+
+ -- [Figure 9.7: Action behaviour concepts]
+
+
+context ActionBehaviour
+ -- 'ActionBehaviour' on 'Tester' components only
+ inv ActionBehaviourComponentRole ('The \'ComponentInstance\' that an \'ActionBehaviour\' refers to shall be of role \'Tester\'.' + self.toString()):
+ self.componentInstance.oclIsUndefined() or self.componentInstance.role = ComponentInstanceRole::Tester
+
+
+ -- Known 'componentInstance' with locally-ordered behaviour
+ inv ActionBehaviourComponentInstance ('The \'ComponentInstance\' that an \'ActionBehaviour\' refers to shall be specified if the \'ActionBehaviour\' is used within a locally-ordered \'TestDescription\'.' + self.toString()):
+ not self.componentInstance.oclIsUndefined() or not self.getParentTestDescription().isLocallyOrdered
+
+
+
+
+context ActionReference
+ -- All action parameters bound
+ inv AllActionParametersBound ('For each \'FormalParameter\' defined in \'formalParameter of\' the referenced \'Action\' there shall be a \'ParameterBinding\' in \'argument\' that refers to that \'FormalParameter\' in \'parameter\'. ' + self.toString()):
+ self.action.formalParameter->forAll(p | self.argument.parameter->includes(p))
+
+
+ -- No 'Function's in 'ActionReference'
+ inv ActionReferenceFunction ('The referenced \'Action\' shall not be a \'Function\'.' + self.toString()):
+ not self.action.oclIsTypeOf(Function)
+
+
+
+
+context Assignment
+ -- Conforming data type
+ inv AssignmentDataType ('The provided \'DataUse\' expression shall conform to the \'DataType\' of the referenced \'Variable\'.' + self.toString()):
+ self.expression.resolveDataType().conformsTo(self.variable.variable.dataType)
+
+
+ -- Empty 'argument' set for 'variable'
+ inv AssignmentVariableArgument ('The \'argument\' and \'reduction\' sets shall be empty.' + self.toString()):
+ self.variable.argument->isEmpty()
+
+
+
+
+
+endpackage
diff --git a/plugins/org.etsi.mts.tdl.constraints/ocl/tdl-structured-constraints.ocl b/plugins/org.etsi.mts.tdl.constraints/ocl/tdl-structured-constraints.ocl
new file mode 100644
index 00000000..dee88616
--- /dev/null
+++ b/plugins/org.etsi.mts.tdl.constraints/ocl/tdl-structured-constraints.ocl
@@ -0,0 +1,134 @@
+import 'http://www.etsi.org/spec/TDL/1.4.1'
+import 'http://www.etsi.org/spec/TDL/1.3.1/structured'
+
+package structuredobjectives
+
+context PICSReference
+ -- Combining Multiple 'PICSReference's
+ inv MultiplePICS ('A \'Comment\' with body containing an \'and\' or \'or\' shall be attached to the \'PICSReference\' as a Boolean operand if there are two or more \'PICSReference\'s and it is not the first \'PICSReference\'.' + self.toString()):
+ self.getTestObjective().picsReference->size() < 2
+ or self.getTestObjective().picsReference->forAll(p |
+ self.getTestObjective().picsReference->at(0) = p
+ or (not p.comment->isEmpty()
+ and (p.comment->first()._'body' = 'and'
+ or p.comment->first()._'body' = 'or')))
+
+
+
+
+context RepeatedEventSequence
+ -- Either 'repetitions', or 'interval' or neither shall be specified
+ inv RepetitionOrInterval ('At most one of the optional properties \'repetitions\' or \'interval\' shall be defined.' + self.toString()):
+ self.repetitions.oclIsUndefined() or self.interval.oclIsUndefined()
+
+
+ -- The 'repetitions' 'Value' shall be countable and positive
+ inv RepetitionCount ('The expression assigned to the \'repetitions\' property shall evaluate to a positive and countable \'Value\'.' + self.toString()):
+ true --This constraint cannot be expressed in OCL
+
+
+ -- The 'interval' 'Value' shall be countable and positive
+ inv RepetitionInterval ('The expression assigned to the \'repetitions\' property shall evaluate to a positive and countable \'Value\'' + self.toString()):
+ true --This constraint cannot be expressed in OCL
+
+
+
+
+--context EventOccurrence
+-- -- Combining Multiple 'EventOccurrence's
+-- inv MultipleEventOccurrences ('A \'Comment\' with body containing an \'and\' or \'or\' shall be attached to the \'EventOccurrence\' as an operand if there are two or more \'EventOccurrence\'s and it is not the first \'EventOccurrence\'.' + self.toString()):
+-- self.container().oclIsTypeOf(EventSpecificationTemplate)
+-- or self.container().events->size() < 2
+-- or self.container().events->forAll(o |
+-- self.container().events->at(0) = o
+-- or (not o.comment->isEmpty()
+-- and (o.comment->first()._'body' = 'and'
+-- or o.comment->first()._'body' = 'or')))
+
+
+
+
+context EntityReference
+ -- An 'Entity' or a 'ComponentInstance' shall be referenced.
+ inv EntityOrComponentInstance ('There shall be a reference to an \'Entity\' or a \'ComponentInstance\' but not both.' + self.toString()):
+ (not self.entity.oclIsUndefined() and self.component.oclIsUndefined())
+ or (self.entity.oclIsUndefined() and not self.component.oclIsUndefined())
+
+
+
+
+context Content
+ -- No nested 'Content's if 'Value' is provided
+ inv ContentOrValue ('Either nested \'Content\'s or \'Value\' may be specified within \'Content\', but not both.' + self.toString()):
+ self.content->isEmpty() or self.value.oclIsUndefined()
+
+
+
+
+context LiteralValueReference
+ -- Referenced 'LiteralValue' visibility
+ inv VisibleValue ('Only \'LiteralValue\'s defined within previous \'EventOccurrence\'s of the containing \'StructuredTestObjective\' may be referenced.' + self.toString()):
+ self.getTestObjective().contains(self.content)
+ and self.getTestObjective().indexOf(self.content) < self.getTestObjective().indexOf(self)
+
+
+
+
+context ContentReference
+ -- Referenced 'Content' visibility
+ inv VisibleContent ('Only \'Content\' defined within previous \'EventOccurrence\'s of the containing \'StructuredTestObjective\' may be referenced.' + self.toString()):
+ self.getTestObjective().contains(self.content)
+ and self.getTestObjective().indexOf(self.content) < self.getTestObjective().indexOf(self)
+
+
+
+
+context DataReference
+ -- 'DataUse' restrictions within 'DataReference'
+ inv DataReferenceContents ('Only \'StaticDataUse\' may be used directly or indirectly in \'ParameterBinding\'s of the \'StaticDataUse\' within a \'DataReference\'.' + self.toString()):
+ self.content.oclIsTypeOf(StaticDataUse)
+ and self.content.argument->forAll(a | a.dataUse.oclIsKindOf(StaticDataUse))
+ and self.content.argument->closure(a |
+ a.dataUse.argument)->forAll(a|a.dataUse.oclIsKindOf(StaticDataUse))
+
+
+ -- No 'reduction' within 'DataReference'
+ inv DataReferenceReduction ('The \'reduction\' property of \'StaticDataUse\' inherited from \'DataUse\' shall not be used within a \'DataReference\'.' + self.toString()):
+ self.content.reduction->isEmpty()
+
+
+
+
+context EventTemplateOccurrence
+ -- 'EntityReference' of referenced 'EventSpecificationTemplate'
+ inv EntityTemplateOccurrenceConsistency ('If \'EntityBinding\'s are provided, the \'Entity\'s or \'ComponentInstance\'s referenced in the \'templateEntity\' properties shall also be referenced by one of the \'EntityReferences\' in the \'EventOccurrenceSpecification\' of the \'EventSpecificationTemplate\' referenced in the \'EventTemplateOccurrence\'.' + self.toString()):
+ self.entityBinding->forAll(b |
+ (not b.templateEntity.entity.oclIsUndefined()
+ and (b.templateEntity.entity =
+ self.eventTemplate.eventSpecification.entityReference.entity))
+ or (not b.templateEntity.component.oclIsUndefined()
+ and (b.templateEntity.component =
+ self.eventTemplate.eventSpecification.entityReference.component)
+ or self.eventTemplate.eventSpecification.oppositeEntityReference->exists(e |
+ (not b.templateEntity.entity.oclIsUndefined()
+ and (e.entity = b.templateEntity.entity))
+ or (not b.templateEntity.component.oclIsUndefined()
+ and (e.component = b.templateEntity.component)))))
+
+
+
+
+context VariantBinding
+ -- Referenced 'Value' of 'VariantBinding'
+ inv VariantBindingValues ('If the \'value\' property references a \'LiteralValue\' or \'Content\' element, the referenced element shall be contained in the \'StructuredTestObjective\' containing the \'VariantBinding\'.' + self.toString()):
+ self.value.oclIsTypeOf(LiteralValueReference) implies
+ self.value.oclAsType(LiteralValueReference).content.getTestObjective() = self.getTestObjective()
+ and
+ self.value.oclIsKindOf(ContentReference) implies
+ self.value.oclAsType(ContentReference).content.getTestObjective() = self.getTestObjective()
+
+
+
+
+
+endpackage
--
GitLab