diff options
Diffstat (limited to 'cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ReadExtentActionTest.java')
| -rwxr-xr-x | cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ReadExtentActionTest.java | 931 |
1 files changed, 931 insertions, 0 deletions
diff --git a/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ReadExtentActionTest.java b/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ReadExtentActionTest.java new file mode 100755 index 00000000..d2fcd7a6 --- /dev/null +++ b/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ReadExtentActionTest.java @@ -0,0 +1,931 @@ +/* + * Copyright (c) 2018 CEA, and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Eike Stepper - initial API and implementation + */ +package org.eclipse.uml2.uml.cdo.tests.compliance; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EAnnotation; + +import org.eclipse.uml2.uml.AcceptCallAction; +import org.eclipse.uml2.uml.AcceptEventAction; +import org.eclipse.uml2.uml.ActionInputPin; +import org.eclipse.uml2.uml.Activity; +import org.eclipse.uml2.uml.ActivityFinalNode; +import org.eclipse.uml2.uml.ActivityGroup; +import org.eclipse.uml2.uml.ActivityParameterNode; +import org.eclipse.uml2.uml.ActivityPartition; +import org.eclipse.uml2.uml.Actor; +import org.eclipse.uml2.uml.AddStructuralFeatureValueAction; +import org.eclipse.uml2.uml.AddVariableValueAction; +import org.eclipse.uml2.uml.Artifact; +import org.eclipse.uml2.uml.Association; +import org.eclipse.uml2.uml.AssociationClass; +import org.eclipse.uml2.uml.BroadcastSignalAction; +import org.eclipse.uml2.uml.CallBehaviorAction; +import org.eclipse.uml2.uml.CallOperationAction; +import org.eclipse.uml2.uml.CentralBufferNode; +import org.eclipse.uml2.uml.Classifier; +import org.eclipse.uml2.uml.ClearAssociationAction; +import org.eclipse.uml2.uml.ClearStructuralFeatureAction; +import org.eclipse.uml2.uml.ClearVariableAction; +import org.eclipse.uml2.uml.Collaboration; +import org.eclipse.uml2.uml.Comment; +import org.eclipse.uml2.uml.CommunicationPath; +import org.eclipse.uml2.uml.Component; +import org.eclipse.uml2.uml.ConditionalNode; +import org.eclipse.uml2.uml.Constraint; +import org.eclipse.uml2.uml.ControlFlow; +import org.eclipse.uml2.uml.CreateLinkAction; +import org.eclipse.uml2.uml.CreateLinkObjectAction; +import org.eclipse.uml2.uml.CreateObjectAction; +import org.eclipse.uml2.uml.DataStoreNode; +import org.eclipse.uml2.uml.DataType; +import org.eclipse.uml2.uml.DecisionNode; +import org.eclipse.uml2.uml.Dependency; +import org.eclipse.uml2.uml.DeploymentSpecification; +import org.eclipse.uml2.uml.DestroyLinkAction; +import org.eclipse.uml2.uml.DestroyObjectAction; +import org.eclipse.uml2.uml.Device; +import org.eclipse.uml2.uml.DurationConstraint; +import org.eclipse.uml2.uml.Element; +import org.eclipse.uml2.uml.Enumeration; +import org.eclipse.uml2.uml.ExceptionHandler; +import org.eclipse.uml2.uml.ExecutionEnvironment; +import org.eclipse.uml2.uml.ExpansionNode; +import org.eclipse.uml2.uml.ExpansionRegion; +import org.eclipse.uml2.uml.Extension; +import org.eclipse.uml2.uml.FlowFinalNode; +import org.eclipse.uml2.uml.ForkNode; +import org.eclipse.uml2.uml.FunctionBehavior; +import org.eclipse.uml2.uml.InformationItem; +import org.eclipse.uml2.uml.InitialNode; +import org.eclipse.uml2.uml.InputPin; +import org.eclipse.uml2.uml.Interaction; +import org.eclipse.uml2.uml.InteractionConstraint; +import org.eclipse.uml2.uml.Interface; +import org.eclipse.uml2.uml.InterruptibleActivityRegion; +import org.eclipse.uml2.uml.IntervalConstraint; +import org.eclipse.uml2.uml.JoinNode; +import org.eclipse.uml2.uml.LoopNode; +import org.eclipse.uml2.uml.MergeNode; +import org.eclipse.uml2.uml.Node; +import org.eclipse.uml2.uml.ObjectFlow; +import org.eclipse.uml2.uml.OpaqueAction; +import org.eclipse.uml2.uml.OpaqueBehavior; +import org.eclipse.uml2.uml.OutputPin; +import org.eclipse.uml2.uml.PrimitiveType; +import org.eclipse.uml2.uml.ProtocolStateMachine; +import org.eclipse.uml2.uml.RaiseExceptionAction; +import org.eclipse.uml2.uml.ReadExtentAction; +import org.eclipse.uml2.uml.ReadIsClassifiedObjectAction; +import org.eclipse.uml2.uml.ReadLinkAction; +import org.eclipse.uml2.uml.ReadLinkObjectEndAction; +import org.eclipse.uml2.uml.ReadLinkObjectEndQualifierAction; +import org.eclipse.uml2.uml.ReadSelfAction; +import org.eclipse.uml2.uml.ReadStructuralFeatureAction; +import org.eclipse.uml2.uml.ReadVariableAction; +import org.eclipse.uml2.uml.ReclassifyObjectAction; +import org.eclipse.uml2.uml.RedefinableElement; +import org.eclipse.uml2.uml.ReduceAction; +import org.eclipse.uml2.uml.RemoveStructuralFeatureValueAction; +import org.eclipse.uml2.uml.RemoveVariableValueAction; +import org.eclipse.uml2.uml.ReplyAction; +import org.eclipse.uml2.uml.SendObjectAction; +import org.eclipse.uml2.uml.SendSignalAction; +import org.eclipse.uml2.uml.SequenceNode; +import org.eclipse.uml2.uml.Signal; +import org.eclipse.uml2.uml.StartClassifierBehaviorAction; +import org.eclipse.uml2.uml.StartObjectBehaviorAction; +import org.eclipse.uml2.uml.StateMachine; +import org.eclipse.uml2.uml.Stereotype; +import org.eclipse.uml2.uml.StringExpression; +import org.eclipse.uml2.uml.StructuredActivityNode; +import org.eclipse.uml2.uml.TestIdentityAction; +import org.eclipse.uml2.uml.TimeConstraint; +import org.eclipse.uml2.uml.UnmarshallAction; +import org.eclipse.uml2.uml.UseCase; +import org.eclipse.uml2.uml.ValuePin; +import org.eclipse.uml2.uml.ValueSpecificationAction; + +/** + * @author Eike Stepper + */ +public class ReadExtentActionTest + extends _Abstract_Compliance_Test_ { + + public void testEAnnotations() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + + EAnnotation eAnnotation = ECORE.createEAnnotation(); + assertValid(eAnnotation); + readExtentAction.getEAnnotations().add(eAnnotation); + } + + public void testOwnedComment() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + + Comment comment = UML.createComment(); + assertValid(comment); + readExtentAction.getOwnedComments().add(comment); + assertSuperset(readExtentAction.getOwnedElements().contains(comment)); + } + + public void testOwnedElement() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + EList<Element> elements = readExtentAction.getOwnedElements(); + EList<Element> elements2 = readExtentAction.getOwnedElements(); + assertSame(elements, elements2); + } + + public void testClientDependency() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + EList<Dependency> dependencys = readExtentAction + .getClientDependencies(); + EList<Dependency> dependencys2 = readExtentAction + .getClientDependencies(); + assertSame(dependencys, dependencys2); + } + + public void testNameExpression() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + + StringExpression stringExpression = UML.createStringExpression(); + assertValid(stringExpression); + readExtentAction.setNameExpression(stringExpression); + assertSuperset( + readExtentAction.getOwnedElements().contains(stringExpression)); + } + + public void testRedefinedElement() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + EList<RedefinableElement> redefinableElements = readExtentAction + .getRedefinedElements(); + EList<RedefinableElement> redefinableElements2 = readExtentAction + .getRedefinedElements(); + assertSame(redefinableElements, redefinableElements2); + } + + public void testRedefinitionContext() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + EList<Classifier> classifiers = readExtentAction + .getRedefinitionContexts(); + EList<Classifier> classifiers2 = readExtentAction + .getRedefinitionContexts(); + assertSame(classifiers, classifiers2); + } + + public void testInGroup() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + EList<ActivityGroup> activityGroups = readExtentAction.getInGroups(); + EList<ActivityGroup> activityGroups2 = readExtentAction.getInGroups(); + assertSame(activityGroups, activityGroups2); + } + + public void testInInterruptibleRegion() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + + InterruptibleActivityRegion interruptibleActivityRegion = UML + .createInterruptibleActivityRegion(); + assertValid(interruptibleActivityRegion); + readExtentAction.getInInterruptibleRegions() + .add(interruptibleActivityRegion); + assertSuperset(readExtentAction.getInGroups() + .contains(interruptibleActivityRegion)); + } + + public void testInStructuredNode() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + + LoopNode loopNode = UML.createLoopNode(); + assertValid(loopNode); + readExtentAction.setInStructuredNode(loopNode); + assertSuperset(readExtentAction.getInGroups().contains(loopNode)); + assertSuperset(readExtentAction.getOwner() == loopNode); + + ExpansionRegion expansionRegion = UML.createExpansionRegion(); + assertValid(expansionRegion); + readExtentAction.setInStructuredNode(expansionRegion); + assertSuperset( + readExtentAction.getInGroups().contains(expansionRegion)); + assertSuperset(readExtentAction.getOwner() == expansionRegion); + + ReadExtentAction readExtentAction2 = UML.createReadExtentAction(); + assertValid(readExtentAction2); + + SequenceNode sequenceNode = UML.createSequenceNode(); + assertValid(sequenceNode); + readExtentAction2.setInStructuredNode(sequenceNode); + assertSuperset(readExtentAction2.getInGroups().contains(sequenceNode)); + assertSuperset(readExtentAction2.getOwner() == sequenceNode); + + StructuredActivityNode structuredActivityNode = UML + .createStructuredActivityNode(); + assertValid(structuredActivityNode); + readExtentAction2.setInStructuredNode(structuredActivityNode); + assertSuperset( + readExtentAction2.getInGroups().contains(structuredActivityNode)); + assertSuperset(readExtentAction2.getOwner() == structuredActivityNode); + + ReadExtentAction readExtentAction3 = UML.createReadExtentAction(); + assertValid(readExtentAction3); + + ConditionalNode conditionalNode = UML.createConditionalNode(); + assertValid(conditionalNode); + readExtentAction3.setInStructuredNode(conditionalNode); + assertSuperset( + readExtentAction3.getInGroups().contains(conditionalNode)); + assertSuperset(readExtentAction3.getOwner() == conditionalNode); + } + + public void testIncoming() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + + ControlFlow controlFlow = UML.createControlFlow(); + assertValid(controlFlow); + readExtentAction.getIncomings().add(controlFlow); + + ObjectFlow objectFlow = UML.createObjectFlow(); + assertValid(objectFlow); + readExtentAction.getIncomings().add(objectFlow); + } + + public void testOutgoing() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + + ControlFlow controlFlow = UML.createControlFlow(); + assertValid(controlFlow); + readExtentAction.getOutgoings().add(controlFlow); + + ObjectFlow objectFlow = UML.createObjectFlow(); + assertValid(objectFlow); + readExtentAction.getOutgoings().add(objectFlow); + } + + public void testRedefinedNode() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + + StartClassifierBehaviorAction startClassifierBehaviorAction = UML + .createStartClassifierBehaviorAction(); + assertValid(startClassifierBehaviorAction); + readExtentAction.getRedefinedNodes().add(startClassifierBehaviorAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(startClassifierBehaviorAction)); + + RemoveVariableValueAction removeVariableValueAction = UML + .createRemoveVariableValueAction(); + assertValid(removeVariableValueAction); + readExtentAction.getRedefinedNodes().add(removeVariableValueAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(removeVariableValueAction)); + + ReadSelfAction readSelfAction = UML.createReadSelfAction(); + assertValid(readSelfAction); + readExtentAction.getRedefinedNodes().add(readSelfAction); + assertSuperset( + readExtentAction.getRedefinedElements().contains(readSelfAction)); + + InputPin inputPin = UML.createInputPin(); + assertValid(inputPin); + readExtentAction.getRedefinedNodes().add(inputPin); + assertSuperset( + readExtentAction.getRedefinedElements().contains(inputPin)); + + ReadLinkObjectEndQualifierAction readLinkObjectEndQualifierAction = UML + .createReadLinkObjectEndQualifierAction(); + assertValid(readLinkObjectEndQualifierAction); + readExtentAction.getRedefinedNodes() + .add(readLinkObjectEndQualifierAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(readLinkObjectEndQualifierAction)); + + JoinNode joinNode = UML.createJoinNode(); + assertValid(joinNode); + readExtentAction.getRedefinedNodes().add(joinNode); + assertSuperset( + readExtentAction.getRedefinedElements().contains(joinNode)); + + CreateLinkObjectAction createLinkObjectAction = UML + .createCreateLinkObjectAction(); + assertValid(createLinkObjectAction); + readExtentAction.getRedefinedNodes().add(createLinkObjectAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(createLinkObjectAction)); + + SendSignalAction sendSignalAction = UML.createSendSignalAction(); + assertValid(sendSignalAction); + readExtentAction.getRedefinedNodes().add(sendSignalAction); + assertSuperset( + readExtentAction.getRedefinedElements().contains(sendSignalAction)); + + ReadLinkAction readLinkAction = UML.createReadLinkAction(); + assertValid(readLinkAction); + readExtentAction.getRedefinedNodes().add(readLinkAction); + assertSuperset( + readExtentAction.getRedefinedElements().contains(readLinkAction)); + + ReplyAction replyAction = UML.createReplyAction(); + assertValid(replyAction); + readExtentAction.getRedefinedNodes().add(replyAction); + assertSuperset( + readExtentAction.getRedefinedElements().contains(replyAction)); + + ClearAssociationAction clearAssociationAction = UML + .createClearAssociationAction(); + assertValid(clearAssociationAction); + readExtentAction.getRedefinedNodes().add(clearAssociationAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(clearAssociationAction)); + + FlowFinalNode flowFinalNode = UML.createFlowFinalNode(); + assertValid(flowFinalNode); + readExtentAction.getRedefinedNodes().add(flowFinalNode); + assertSuperset( + readExtentAction.getRedefinedElements().contains(flowFinalNode)); + + ClearStructuralFeatureAction clearStructuralFeatureAction = UML + .createClearStructuralFeatureAction(); + assertValid(clearStructuralFeatureAction); + readExtentAction.getRedefinedNodes().add(clearStructuralFeatureAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(clearStructuralFeatureAction)); + + ExpansionRegion expansionRegion = UML.createExpansionRegion(); + assertValid(expansionRegion); + readExtentAction.getRedefinedNodes().add(expansionRegion); + assertSuperset( + readExtentAction.getRedefinedElements().contains(expansionRegion)); + + StructuredActivityNode structuredActivityNode = UML + .createStructuredActivityNode(); + assertValid(structuredActivityNode); + readExtentAction.getRedefinedNodes().add(structuredActivityNode); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(structuredActivityNode)); + + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + readExtentAction.getRedefinedNodes().add(valuePin); + assertSuperset( + readExtentAction.getRedefinedElements().contains(valuePin)); + + StartObjectBehaviorAction startObjectBehaviorAction = UML + .createStartObjectBehaviorAction(); + assertValid(startObjectBehaviorAction); + readExtentAction.getRedefinedNodes().add(startObjectBehaviorAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(startObjectBehaviorAction)); + + ForkNode forkNode = UML.createForkNode(); + assertValid(forkNode); + readExtentAction.getRedefinedNodes().add(forkNode); + assertSuperset( + readExtentAction.getRedefinedElements().contains(forkNode)); + + DecisionNode decisionNode = UML.createDecisionNode(); + assertValid(decisionNode); + readExtentAction.getRedefinedNodes().add(decisionNode); + assertSuperset( + readExtentAction.getRedefinedElements().contains(decisionNode)); + + CallBehaviorAction callBehaviorAction = UML.createCallBehaviorAction(); + assertValid(callBehaviorAction); + readExtentAction.getRedefinedNodes().add(callBehaviorAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(callBehaviorAction)); + + ConditionalNode conditionalNode = UML.createConditionalNode(); + assertValid(conditionalNode); + readExtentAction.getRedefinedNodes().add(conditionalNode); + assertSuperset( + readExtentAction.getRedefinedElements().contains(conditionalNode)); + + ReadExtentAction readExtentAction2 = UML.createReadExtentAction(); + assertValid(readExtentAction2); + readExtentAction.getRedefinedNodes().add(readExtentAction2); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(readExtentAction2)); + + ActionInputPin actionInputPin = UML.createActionInputPin(); + assertValid(actionInputPin); + readExtentAction.getRedefinedNodes().add(actionInputPin); + assertSuperset( + readExtentAction.getRedefinedElements().contains(actionInputPin)); + + ReadIsClassifiedObjectAction readIsClassifiedObjectAction = UML + .createReadIsClassifiedObjectAction(); + assertValid(readIsClassifiedObjectAction); + readExtentAction.getRedefinedNodes().add(readIsClassifiedObjectAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(readIsClassifiedObjectAction)); + + ActivityParameterNode activityParameterNode = UML + .createActivityParameterNode(); + assertValid(activityParameterNode); + readExtentAction.getRedefinedNodes().add(activityParameterNode); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(activityParameterNode)); + + AddStructuralFeatureValueAction addStructuralFeatureValueAction = UML + .createAddStructuralFeatureValueAction(); + assertValid(addStructuralFeatureValueAction); + readExtentAction.getRedefinedNodes() + .add(addStructuralFeatureValueAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(addStructuralFeatureValueAction)); + + ReadVariableAction readVariableAction = UML.createReadVariableAction(); + assertValid(readVariableAction); + readExtentAction.getRedefinedNodes().add(readVariableAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(readVariableAction)); + + ClearVariableAction clearVariableAction = UML + .createClearVariableAction(); + assertValid(clearVariableAction); + readExtentAction.getRedefinedNodes().add(clearVariableAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(clearVariableAction)); + + RemoveStructuralFeatureValueAction removeStructuralFeatureValueAction = UML + .createRemoveStructuralFeatureValueAction(); + assertValid(removeStructuralFeatureValueAction); + readExtentAction.getRedefinedNodes() + .add(removeStructuralFeatureValueAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(removeStructuralFeatureValueAction)); + + CreateLinkAction createLinkAction = UML.createCreateLinkAction(); + assertValid(createLinkAction); + readExtentAction.getRedefinedNodes().add(createLinkAction); + assertSuperset( + readExtentAction.getRedefinedElements().contains(createLinkAction)); + + ReclassifyObjectAction reclassifyObjectAction = UML + .createReclassifyObjectAction(); + assertValid(reclassifyObjectAction); + readExtentAction.getRedefinedNodes().add(reclassifyObjectAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(reclassifyObjectAction)); + + DataStoreNode dataStoreNode = UML.createDataStoreNode(); + assertValid(dataStoreNode); + readExtentAction.getRedefinedNodes().add(dataStoreNode); + assertSuperset( + readExtentAction.getRedefinedElements().contains(dataStoreNode)); + + SendObjectAction sendObjectAction = UML.createSendObjectAction(); + assertValid(sendObjectAction); + readExtentAction.getRedefinedNodes().add(sendObjectAction); + assertSuperset( + readExtentAction.getRedefinedElements().contains(sendObjectAction)); + + ReduceAction reduceAction = UML.createReduceAction(); + assertValid(reduceAction); + readExtentAction.getRedefinedNodes().add(reduceAction); + assertSuperset( + readExtentAction.getRedefinedElements().contains(reduceAction)); + + AcceptEventAction acceptEventAction = UML.createAcceptEventAction(); + assertValid(acceptEventAction); + readExtentAction.getRedefinedNodes().add(acceptEventAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(acceptEventAction)); + + DestroyLinkAction destroyLinkAction = UML.createDestroyLinkAction(); + assertValid(destroyLinkAction); + readExtentAction.getRedefinedNodes().add(destroyLinkAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(destroyLinkAction)); + + ExpansionNode expansionNode = UML.createExpansionNode(); + assertValid(expansionNode); + readExtentAction.getRedefinedNodes().add(expansionNode); + assertSuperset( + readExtentAction.getRedefinedElements().contains(expansionNode)); + + InitialNode initialNode = UML.createInitialNode(); + assertValid(initialNode); + readExtentAction.getRedefinedNodes().add(initialNode); + assertSuperset( + readExtentAction.getRedefinedElements().contains(initialNode)); + + TestIdentityAction testIdentityAction = UML.createTestIdentityAction(); + assertValid(testIdentityAction); + readExtentAction.getRedefinedNodes().add(testIdentityAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(testIdentityAction)); + + OutputPin outputPin = UML.createOutputPin(); + assertValid(outputPin); + readExtentAction.getRedefinedNodes().add(outputPin); + assertSuperset( + readExtentAction.getRedefinedElements().contains(outputPin)); + + CentralBufferNode centralBufferNode = UML.createCentralBufferNode(); + assertValid(centralBufferNode); + readExtentAction.getRedefinedNodes().add(centralBufferNode); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(centralBufferNode)); + + BroadcastSignalAction broadcastSignalAction = UML + .createBroadcastSignalAction(); + assertValid(broadcastSignalAction); + readExtentAction.getRedefinedNodes().add(broadcastSignalAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(broadcastSignalAction)); + + RaiseExceptionAction raiseExceptionAction = UML + .createRaiseExceptionAction(); + assertValid(raiseExceptionAction); + readExtentAction.getRedefinedNodes().add(raiseExceptionAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(raiseExceptionAction)); + + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + readExtentAction.getRedefinedNodes().add(activityFinalNode); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(activityFinalNode)); + + CallOperationAction callOperationAction = UML + .createCallOperationAction(); + assertValid(callOperationAction); + readExtentAction.getRedefinedNodes().add(callOperationAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(callOperationAction)); + + LoopNode loopNode = UML.createLoopNode(); + assertValid(loopNode); + readExtentAction.getRedefinedNodes().add(loopNode); + assertSuperset( + readExtentAction.getRedefinedElements().contains(loopNode)); + + ValueSpecificationAction valueSpecificationAction = UML + .createValueSpecificationAction(); + assertValid(valueSpecificationAction); + readExtentAction.getRedefinedNodes().add(valueSpecificationAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(valueSpecificationAction)); + + AcceptCallAction acceptCallAction = UML.createAcceptCallAction(); + assertValid(acceptCallAction); + readExtentAction.getRedefinedNodes().add(acceptCallAction); + assertSuperset( + readExtentAction.getRedefinedElements().contains(acceptCallAction)); + + AddVariableValueAction addVariableValueAction = UML + .createAddVariableValueAction(); + assertValid(addVariableValueAction); + readExtentAction.getRedefinedNodes().add(addVariableValueAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(addVariableValueAction)); + + ReadLinkObjectEndAction readLinkObjectEndAction = UML + .createReadLinkObjectEndAction(); + assertValid(readLinkObjectEndAction); + readExtentAction.getRedefinedNodes().add(readLinkObjectEndAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(readLinkObjectEndAction)); + + UnmarshallAction unmarshallAction = UML.createUnmarshallAction(); + assertValid(unmarshallAction); + readExtentAction.getRedefinedNodes().add(unmarshallAction); + assertSuperset( + readExtentAction.getRedefinedElements().contains(unmarshallAction)); + + OpaqueAction opaqueAction = UML.createOpaqueAction(); + assertValid(opaqueAction); + readExtentAction.getRedefinedNodes().add(opaqueAction); + assertSuperset( + readExtentAction.getRedefinedElements().contains(opaqueAction)); + + MergeNode mergeNode = UML.createMergeNode(); + assertValid(mergeNode); + readExtentAction.getRedefinedNodes().add(mergeNode); + assertSuperset( + readExtentAction.getRedefinedElements().contains(mergeNode)); + + SequenceNode sequenceNode = UML.createSequenceNode(); + assertValid(sequenceNode); + readExtentAction.getRedefinedNodes().add(sequenceNode); + assertSuperset( + readExtentAction.getRedefinedElements().contains(sequenceNode)); + + CreateObjectAction createObjectAction = UML.createCreateObjectAction(); + assertValid(createObjectAction); + readExtentAction.getRedefinedNodes().add(createObjectAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(createObjectAction)); + + DestroyObjectAction destroyObjectAction = UML + .createDestroyObjectAction(); + assertValid(destroyObjectAction); + readExtentAction.getRedefinedNodes().add(destroyObjectAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(destroyObjectAction)); + + ReadStructuralFeatureAction readStructuralFeatureAction = UML + .createReadStructuralFeatureAction(); + assertValid(readStructuralFeatureAction); + readExtentAction.getRedefinedNodes().add(readStructuralFeatureAction); + assertSuperset(readExtentAction.getRedefinedElements() + .contains(readStructuralFeatureAction)); + } + + public void testInPartition() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + + ActivityPartition activityPartition = UML.createActivityPartition(); + assertValid(activityPartition); + readExtentAction.getInPartitions().add(activityPartition); + assertSuperset( + readExtentAction.getInGroups().contains(activityPartition)); + } + + public void testHandler() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + + ExceptionHandler exceptionHandler = UML.createExceptionHandler(); + assertValid(exceptionHandler); + readExtentAction.getHandlers().add(exceptionHandler); + assertSuperset( + readExtentAction.getOwnedElements().contains(exceptionHandler)); + } + + public void testInput() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + EList<InputPin> inputPins = readExtentAction.getInputs(); + EList<InputPin> inputPins2 = readExtentAction.getInputs(); + assertSame(inputPins, inputPins2); + } + + public void testLocalPostcondition() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + + IntervalConstraint intervalConstraint = UML.createIntervalConstraint(); + assertValid(intervalConstraint); + readExtentAction.getLocalPostconditions().add(intervalConstraint); + assertSuperset( + readExtentAction.getOwnedElements().contains(intervalConstraint)); + + TimeConstraint timeConstraint = UML.createTimeConstraint(); + assertValid(timeConstraint); + readExtentAction.getLocalPostconditions().add(timeConstraint); + assertSuperset( + readExtentAction.getOwnedElements().contains(timeConstraint)); + + InteractionConstraint interactionConstraint = UML + .createInteractionConstraint(); + assertValid(interactionConstraint); + readExtentAction.getLocalPostconditions().add(interactionConstraint); + assertSuperset(readExtentAction.getOwnedElements() + .contains(interactionConstraint)); + + Constraint constraint = UML.createConstraint(); + assertValid(constraint); + readExtentAction.getLocalPostconditions().add(constraint); + assertSuperset( + readExtentAction.getOwnedElements().contains(constraint)); + + DurationConstraint durationConstraint = UML.createDurationConstraint(); + assertValid(durationConstraint); + readExtentAction.getLocalPostconditions().add(durationConstraint); + assertSuperset( + readExtentAction.getOwnedElements().contains(durationConstraint)); + } + + public void testLocalPrecondition() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + + IntervalConstraint intervalConstraint = UML.createIntervalConstraint(); + assertValid(intervalConstraint); + readExtentAction.getLocalPreconditions().add(intervalConstraint); + assertSuperset( + readExtentAction.getOwnedElements().contains(intervalConstraint)); + + TimeConstraint timeConstraint = UML.createTimeConstraint(); + assertValid(timeConstraint); + readExtentAction.getLocalPreconditions().add(timeConstraint); + assertSuperset( + readExtentAction.getOwnedElements().contains(timeConstraint)); + + InteractionConstraint interactionConstraint = UML + .createInteractionConstraint(); + assertValid(interactionConstraint); + readExtentAction.getLocalPreconditions().add(interactionConstraint); + assertSuperset(readExtentAction.getOwnedElements() + .contains(interactionConstraint)); + + Constraint constraint = UML.createConstraint(); + assertValid(constraint); + readExtentAction.getLocalPreconditions().add(constraint); + assertSuperset( + readExtentAction.getOwnedElements().contains(constraint)); + + DurationConstraint durationConstraint = UML.createDurationConstraint(); + assertValid(durationConstraint); + readExtentAction.getLocalPreconditions().add(durationConstraint); + assertSuperset( + readExtentAction.getOwnedElements().contains(durationConstraint)); + } + + public void testOutput() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + EList<OutputPin> outputPins = readExtentAction.getOutputs(); + EList<OutputPin> outputPins2 = readExtentAction.getOutputs(); + assertSame(outputPins, outputPins2); + } + + public void testClassifier() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + + FunctionBehavior functionBehavior = UML.createFunctionBehavior(); + assertValid(functionBehavior); + readExtentAction.setClassifier(functionBehavior); + + Activity activity = UML.createActivity(); + assertValid(activity); + readExtentAction.setClassifier(activity); + + ReadExtentAction readExtentAction2 = UML.createReadExtentAction(); + assertValid(readExtentAction2); + + Interface interface_ = UML.createInterface(); + assertValid(interface_); + readExtentAction2.setClassifier(interface_); + + InformationItem informationItem = UML.createInformationItem(); + assertValid(informationItem); + readExtentAction2.setClassifier(informationItem); + + ReadExtentAction readExtentAction3 = UML.createReadExtentAction(); + assertValid(readExtentAction3); + + CommunicationPath communicationPath = UML.createCommunicationPath(); + assertValid(communicationPath); + readExtentAction3.setClassifier(communicationPath); + + ExecutionEnvironment executionEnvironment = UML + .createExecutionEnvironment(); + assertValid(executionEnvironment); + readExtentAction3.setClassifier(executionEnvironment); + + ReadExtentAction readExtentAction4 = UML.createReadExtentAction(); + assertValid(readExtentAction4); + + Component component = UML.createComponent(); + assertValid(component); + readExtentAction4.setClassifier(component); + + Interaction interaction = UML.createInteraction(); + assertValid(interaction); + readExtentAction4.setClassifier(interaction); + + ReadExtentAction readExtentAction5 = UML.createReadExtentAction(); + assertValid(readExtentAction5); + + DeploymentSpecification deploymentSpecification = UML + .createDeploymentSpecification(); + assertValid(deploymentSpecification); + readExtentAction5.setClassifier(deploymentSpecification); + + OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior(); + assertValid(opaqueBehavior); + readExtentAction5.setClassifier(opaqueBehavior); + + ReadExtentAction readExtentAction6 = UML.createReadExtentAction(); + assertValid(readExtentAction6); + + Association association = UML.createAssociation(); + assertValid(association); + readExtentAction6.setClassifier(association); + + DataType dataType = UML.createDataType(); + assertValid(dataType); + readExtentAction6.setClassifier(dataType); + + ReadExtentAction readExtentAction7 = UML.createReadExtentAction(); + assertValid(readExtentAction7); + + Device device = UML.createDevice(); + assertValid(device); + readExtentAction7.setClassifier(device); + + Extension extension = UML.createExtension(); + assertValid(extension); + readExtentAction7.setClassifier(extension); + + ReadExtentAction readExtentAction8 = UML.createReadExtentAction(); + assertValid(readExtentAction8); + + AssociationClass associationClass = UML.createAssociationClass(); + assertValid(associationClass); + readExtentAction8.setClassifier(associationClass); + + org.eclipse.uml2.uml.Class class_ = UML.createClass(); + assertValid(class_); + readExtentAction8.setClassifier(class_); + + ReadExtentAction readExtentAction9 = UML.createReadExtentAction(); + assertValid(readExtentAction9); + + Enumeration enumeration = UML.createEnumeration(); + assertValid(enumeration); + readExtentAction9.setClassifier(enumeration); + + PrimitiveType primitiveType = UML.createPrimitiveType(); + assertValid(primitiveType); + readExtentAction9.setClassifier(primitiveType); + + ReadExtentAction readExtentAction10 = UML.createReadExtentAction(); + assertValid(readExtentAction10); + + Actor actor = UML.createActor(); + assertValid(actor); + readExtentAction10.setClassifier(actor); + + ProtocolStateMachine protocolStateMachine = UML + .createProtocolStateMachine(); + assertValid(protocolStateMachine); + readExtentAction10.setClassifier(protocolStateMachine); + + ReadExtentAction readExtentAction11 = UML.createReadExtentAction(); + assertValid(readExtentAction11); + + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + readExtentAction11.setClassifier(useCase); + + Signal signal = UML.createSignal(); + assertValid(signal); + readExtentAction11.setClassifier(signal); + + ReadExtentAction readExtentAction12 = UML.createReadExtentAction(); + assertValid(readExtentAction12); + + Node node = UML.createNode(); + assertValid(node); + readExtentAction12.setClassifier(node); + + Stereotype stereotype = UML.createStereotype(); + assertValid(stereotype); + readExtentAction12.setClassifier(stereotype); + + ReadExtentAction readExtentAction13 = UML.createReadExtentAction(); + assertValid(readExtentAction13); + + StateMachine stateMachine = UML.createStateMachine(); + assertValid(stateMachine); + readExtentAction13.setClassifier(stateMachine); + + Artifact artifact = UML.createArtifact(); + assertValid(artifact); + readExtentAction13.setClassifier(artifact); + + ReadExtentAction readExtentAction14 = UML.createReadExtentAction(); + assertValid(readExtentAction14); + + Collaboration collaboration = UML.createCollaboration(); + assertValid(collaboration); + readExtentAction14.setClassifier(collaboration); + } + + public void testResult() { + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + + OutputPin outputPin = UML.createOutputPin(); + assertValid(outputPin); + readExtentAction.setResult(outputPin); + assertSuperset(readExtentAction.getOutputs().contains(outputPin)); + } + +} |