diff options
Diffstat (limited to 'cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ActivityFinalNodeTest.java')
-rwxr-xr-x | cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ActivityFinalNodeTest.java | 627 |
1 files changed, 627 insertions, 0 deletions
diff --git a/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ActivityFinalNodeTest.java b/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ActivityFinalNodeTest.java new file mode 100755 index 00000000..05d4618c --- /dev/null +++ b/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ActivityFinalNodeTest.java @@ -0,0 +1,627 @@ +/* + * 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.ActivityFinalNode; +import org.eclipse.uml2.uml.ActivityGroup; +import org.eclipse.uml2.uml.ActivityParameterNode; +import org.eclipse.uml2.uml.ActivityPartition; +import org.eclipse.uml2.uml.AddStructuralFeatureValueAction; +import org.eclipse.uml2.uml.AddVariableValueAction; +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.Comment; +import org.eclipse.uml2.uml.ConditionalNode; +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.DecisionNode; +import org.eclipse.uml2.uml.Dependency; +import org.eclipse.uml2.uml.DestroyLinkAction; +import org.eclipse.uml2.uml.DestroyObjectAction; +import org.eclipse.uml2.uml.Element; +import org.eclipse.uml2.uml.ExpansionNode; +import org.eclipse.uml2.uml.ExpansionRegion; +import org.eclipse.uml2.uml.FlowFinalNode; +import org.eclipse.uml2.uml.ForkNode; +import org.eclipse.uml2.uml.InitialNode; +import org.eclipse.uml2.uml.InputPin; +import org.eclipse.uml2.uml.InterruptibleActivityRegion; +import org.eclipse.uml2.uml.JoinNode; +import org.eclipse.uml2.uml.LoopNode; +import org.eclipse.uml2.uml.MergeNode; +import org.eclipse.uml2.uml.ObjectFlow; +import org.eclipse.uml2.uml.OpaqueAction; +import org.eclipse.uml2.uml.OutputPin; +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.StartClassifierBehaviorAction; +import org.eclipse.uml2.uml.StartObjectBehaviorAction; +import org.eclipse.uml2.uml.StringExpression; +import org.eclipse.uml2.uml.StructuredActivityNode; +import org.eclipse.uml2.uml.TestIdentityAction; +import org.eclipse.uml2.uml.UnmarshallAction; +import org.eclipse.uml2.uml.ValuePin; +import org.eclipse.uml2.uml.ValueSpecificationAction; + +/** + * @author Eike Stepper + */ +public class ActivityFinalNodeTest + extends _Abstract_Compliance_Test_ { + + public void testEAnnotations() { + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + + EAnnotation eAnnotation = ECORE.createEAnnotation(); + assertValid(eAnnotation); + activityFinalNode.getEAnnotations().add(eAnnotation); + } + + public void testOwnedComment() { + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + + Comment comment = UML.createComment(); + assertValid(comment); + activityFinalNode.getOwnedComments().add(comment); + assertSuperset(activityFinalNode.getOwnedElements().contains(comment)); + } + + public void testOwnedElement() { + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + EList<Element> elements = activityFinalNode.getOwnedElements(); + EList<Element> elements2 = activityFinalNode.getOwnedElements(); + assertSame(elements, elements2); + } + + public void testClientDependency() { + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + EList<Dependency> dependencys = activityFinalNode + .getClientDependencies(); + EList<Dependency> dependencys2 = activityFinalNode + .getClientDependencies(); + assertSame(dependencys, dependencys2); + } + + public void testNameExpression() { + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + + StringExpression stringExpression = UML.createStringExpression(); + assertValid(stringExpression); + activityFinalNode.setNameExpression(stringExpression); + assertSuperset( + activityFinalNode.getOwnedElements().contains(stringExpression)); + } + + public void testRedefinedElement() { + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + EList<RedefinableElement> redefinableElements = activityFinalNode + .getRedefinedElements(); + EList<RedefinableElement> redefinableElements2 = activityFinalNode + .getRedefinedElements(); + assertSame(redefinableElements, redefinableElements2); + } + + public void testRedefinitionContext() { + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + EList<Classifier> classifiers = activityFinalNode + .getRedefinitionContexts(); + EList<Classifier> classifiers2 = activityFinalNode + .getRedefinitionContexts(); + assertSame(classifiers, classifiers2); + } + + public void testInGroup() { + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + EList<ActivityGroup> activityGroups = activityFinalNode.getInGroups(); + EList<ActivityGroup> activityGroups2 = activityFinalNode.getInGroups(); + assertSame(activityGroups, activityGroups2); + } + + public void testInInterruptibleRegion() { + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + + InterruptibleActivityRegion interruptibleActivityRegion = UML + .createInterruptibleActivityRegion(); + assertValid(interruptibleActivityRegion); + activityFinalNode.getInInterruptibleRegions() + .add(interruptibleActivityRegion); + assertSuperset(activityFinalNode.getInGroups() + .contains(interruptibleActivityRegion)); + } + + public void testInStructuredNode() { + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + + LoopNode loopNode = UML.createLoopNode(); + assertValid(loopNode); + activityFinalNode.setInStructuredNode(loopNode); + assertSuperset(activityFinalNode.getInGroups().contains(loopNode)); + assertSuperset(activityFinalNode.getOwner() == loopNode); + + ExpansionRegion expansionRegion = UML.createExpansionRegion(); + assertValid(expansionRegion); + activityFinalNode.setInStructuredNode(expansionRegion); + assertSuperset( + activityFinalNode.getInGroups().contains(expansionRegion)); + assertSuperset(activityFinalNode.getOwner() == expansionRegion); + + ActivityFinalNode activityFinalNode2 = UML.createActivityFinalNode(); + assertValid(activityFinalNode2); + + StructuredActivityNode structuredActivityNode = UML + .createStructuredActivityNode(); + assertValid(structuredActivityNode); + activityFinalNode2.setInStructuredNode(structuredActivityNode); + assertSuperset( + activityFinalNode2.getInGroups().contains(structuredActivityNode)); + assertSuperset(activityFinalNode2.getOwner() == structuredActivityNode); + + ConditionalNode conditionalNode = UML.createConditionalNode(); + assertValid(conditionalNode); + activityFinalNode2.setInStructuredNode(conditionalNode); + assertSuperset( + activityFinalNode2.getInGroups().contains(conditionalNode)); + assertSuperset(activityFinalNode2.getOwner() == conditionalNode); + } + + public void testIncoming() { + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + + ControlFlow controlFlow = UML.createControlFlow(); + assertValid(controlFlow); + activityFinalNode.getIncomings().add(controlFlow); + + ObjectFlow objectFlow = UML.createObjectFlow(); + assertValid(objectFlow); + activityFinalNode.getIncomings().add(objectFlow); + } + + public void testOutgoing() { + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + + ControlFlow controlFlow = UML.createControlFlow(); + assertValid(controlFlow); + activityFinalNode.getOutgoings().add(controlFlow); + + ObjectFlow objectFlow = UML.createObjectFlow(); + assertValid(objectFlow); + activityFinalNode.getOutgoings().add(objectFlow); + } + + public void testRedefinedNode() { + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + + StartClassifierBehaviorAction startClassifierBehaviorAction = UML + .createStartClassifierBehaviorAction(); + assertValid(startClassifierBehaviorAction); + activityFinalNode.getRedefinedNodes() + .add(startClassifierBehaviorAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(startClassifierBehaviorAction)); + + RemoveVariableValueAction removeVariableValueAction = UML + .createRemoveVariableValueAction(); + assertValid(removeVariableValueAction); + activityFinalNode.getRedefinedNodes().add(removeVariableValueAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(removeVariableValueAction)); + + ReadSelfAction readSelfAction = UML.createReadSelfAction(); + assertValid(readSelfAction); + activityFinalNode.getRedefinedNodes().add(readSelfAction); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(readSelfAction)); + + InputPin inputPin = UML.createInputPin(); + assertValid(inputPin); + activityFinalNode.getRedefinedNodes().add(inputPin); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(inputPin)); + + ReadLinkObjectEndQualifierAction readLinkObjectEndQualifierAction = UML + .createReadLinkObjectEndQualifierAction(); + assertValid(readLinkObjectEndQualifierAction); + activityFinalNode.getRedefinedNodes() + .add(readLinkObjectEndQualifierAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(readLinkObjectEndQualifierAction)); + + JoinNode joinNode = UML.createJoinNode(); + assertValid(joinNode); + activityFinalNode.getRedefinedNodes().add(joinNode); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(joinNode)); + + CreateLinkObjectAction createLinkObjectAction = UML + .createCreateLinkObjectAction(); + assertValid(createLinkObjectAction); + activityFinalNode.getRedefinedNodes().add(createLinkObjectAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(createLinkObjectAction)); + + SendSignalAction sendSignalAction = UML.createSendSignalAction(); + assertValid(sendSignalAction); + activityFinalNode.getRedefinedNodes().add(sendSignalAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(sendSignalAction)); + + ReadLinkAction readLinkAction = UML.createReadLinkAction(); + assertValid(readLinkAction); + activityFinalNode.getRedefinedNodes().add(readLinkAction); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(readLinkAction)); + + ReplyAction replyAction = UML.createReplyAction(); + assertValid(replyAction); + activityFinalNode.getRedefinedNodes().add(replyAction); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(replyAction)); + + ClearAssociationAction clearAssociationAction = UML + .createClearAssociationAction(); + assertValid(clearAssociationAction); + activityFinalNode.getRedefinedNodes().add(clearAssociationAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(clearAssociationAction)); + + FlowFinalNode flowFinalNode = UML.createFlowFinalNode(); + assertValid(flowFinalNode); + activityFinalNode.getRedefinedNodes().add(flowFinalNode); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(flowFinalNode)); + + ClearStructuralFeatureAction clearStructuralFeatureAction = UML + .createClearStructuralFeatureAction(); + assertValid(clearStructuralFeatureAction); + activityFinalNode.getRedefinedNodes().add(clearStructuralFeatureAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(clearStructuralFeatureAction)); + + ExpansionRegion expansionRegion = UML.createExpansionRegion(); + assertValid(expansionRegion); + activityFinalNode.getRedefinedNodes().add(expansionRegion); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(expansionRegion)); + + StructuredActivityNode structuredActivityNode = UML + .createStructuredActivityNode(); + assertValid(structuredActivityNode); + activityFinalNode.getRedefinedNodes().add(structuredActivityNode); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(structuredActivityNode)); + + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + activityFinalNode.getRedefinedNodes().add(valuePin); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(valuePin)); + + StartObjectBehaviorAction startObjectBehaviorAction = UML + .createStartObjectBehaviorAction(); + assertValid(startObjectBehaviorAction); + activityFinalNode.getRedefinedNodes().add(startObjectBehaviorAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(startObjectBehaviorAction)); + + ForkNode forkNode = UML.createForkNode(); + assertValid(forkNode); + activityFinalNode.getRedefinedNodes().add(forkNode); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(forkNode)); + + DecisionNode decisionNode = UML.createDecisionNode(); + assertValid(decisionNode); + activityFinalNode.getRedefinedNodes().add(decisionNode); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(decisionNode)); + + CallBehaviorAction callBehaviorAction = UML.createCallBehaviorAction(); + assertValid(callBehaviorAction); + activityFinalNode.getRedefinedNodes().add(callBehaviorAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(callBehaviorAction)); + + ConditionalNode conditionalNode = UML.createConditionalNode(); + assertValid(conditionalNode); + activityFinalNode.getRedefinedNodes().add(conditionalNode); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(conditionalNode)); + + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + activityFinalNode.getRedefinedNodes().add(readExtentAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(readExtentAction)); + + ActionInputPin actionInputPin = UML.createActionInputPin(); + assertValid(actionInputPin); + activityFinalNode.getRedefinedNodes().add(actionInputPin); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(actionInputPin)); + + ReadIsClassifiedObjectAction readIsClassifiedObjectAction = UML + .createReadIsClassifiedObjectAction(); + assertValid(readIsClassifiedObjectAction); + activityFinalNode.getRedefinedNodes().add(readIsClassifiedObjectAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(readIsClassifiedObjectAction)); + + ActivityParameterNode activityParameterNode = UML + .createActivityParameterNode(); + assertValid(activityParameterNode); + activityFinalNode.getRedefinedNodes().add(activityParameterNode); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(activityParameterNode)); + + AddStructuralFeatureValueAction addStructuralFeatureValueAction = UML + .createAddStructuralFeatureValueAction(); + assertValid(addStructuralFeatureValueAction); + activityFinalNode.getRedefinedNodes() + .add(addStructuralFeatureValueAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(addStructuralFeatureValueAction)); + + ReadVariableAction readVariableAction = UML.createReadVariableAction(); + assertValid(readVariableAction); + activityFinalNode.getRedefinedNodes().add(readVariableAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(readVariableAction)); + + ClearVariableAction clearVariableAction = UML + .createClearVariableAction(); + assertValid(clearVariableAction); + activityFinalNode.getRedefinedNodes().add(clearVariableAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(clearVariableAction)); + + RemoveStructuralFeatureValueAction removeStructuralFeatureValueAction = UML + .createRemoveStructuralFeatureValueAction(); + assertValid(removeStructuralFeatureValueAction); + activityFinalNode.getRedefinedNodes() + .add(removeStructuralFeatureValueAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(removeStructuralFeatureValueAction)); + + CreateLinkAction createLinkAction = UML.createCreateLinkAction(); + assertValid(createLinkAction); + activityFinalNode.getRedefinedNodes().add(createLinkAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(createLinkAction)); + + ReclassifyObjectAction reclassifyObjectAction = UML + .createReclassifyObjectAction(); + assertValid(reclassifyObjectAction); + activityFinalNode.getRedefinedNodes().add(reclassifyObjectAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(reclassifyObjectAction)); + + DataStoreNode dataStoreNode = UML.createDataStoreNode(); + assertValid(dataStoreNode); + activityFinalNode.getRedefinedNodes().add(dataStoreNode); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(dataStoreNode)); + + SendObjectAction sendObjectAction = UML.createSendObjectAction(); + assertValid(sendObjectAction); + activityFinalNode.getRedefinedNodes().add(sendObjectAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(sendObjectAction)); + + ReduceAction reduceAction = UML.createReduceAction(); + assertValid(reduceAction); + activityFinalNode.getRedefinedNodes().add(reduceAction); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(reduceAction)); + + AcceptEventAction acceptEventAction = UML.createAcceptEventAction(); + assertValid(acceptEventAction); + activityFinalNode.getRedefinedNodes().add(acceptEventAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(acceptEventAction)); + + DestroyLinkAction destroyLinkAction = UML.createDestroyLinkAction(); + assertValid(destroyLinkAction); + activityFinalNode.getRedefinedNodes().add(destroyLinkAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(destroyLinkAction)); + + ExpansionNode expansionNode = UML.createExpansionNode(); + assertValid(expansionNode); + activityFinalNode.getRedefinedNodes().add(expansionNode); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(expansionNode)); + + InitialNode initialNode = UML.createInitialNode(); + assertValid(initialNode); + activityFinalNode.getRedefinedNodes().add(initialNode); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(initialNode)); + + TestIdentityAction testIdentityAction = UML.createTestIdentityAction(); + assertValid(testIdentityAction); + activityFinalNode.getRedefinedNodes().add(testIdentityAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(testIdentityAction)); + + OutputPin outputPin = UML.createOutputPin(); + assertValid(outputPin); + activityFinalNode.getRedefinedNodes().add(outputPin); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(outputPin)); + + CentralBufferNode centralBufferNode = UML.createCentralBufferNode(); + assertValid(centralBufferNode); + activityFinalNode.getRedefinedNodes().add(centralBufferNode); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(centralBufferNode)); + + BroadcastSignalAction broadcastSignalAction = UML + .createBroadcastSignalAction(); + assertValid(broadcastSignalAction); + activityFinalNode.getRedefinedNodes().add(broadcastSignalAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(broadcastSignalAction)); + + RaiseExceptionAction raiseExceptionAction = UML + .createRaiseExceptionAction(); + assertValid(raiseExceptionAction); + activityFinalNode.getRedefinedNodes().add(raiseExceptionAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(raiseExceptionAction)); + + ActivityFinalNode activityFinalNode2 = UML.createActivityFinalNode(); + assertValid(activityFinalNode2); + activityFinalNode.getRedefinedNodes().add(activityFinalNode2); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(activityFinalNode2)); + + CallOperationAction callOperationAction = UML + .createCallOperationAction(); + assertValid(callOperationAction); + activityFinalNode.getRedefinedNodes().add(callOperationAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(callOperationAction)); + + LoopNode loopNode = UML.createLoopNode(); + assertValid(loopNode); + activityFinalNode.getRedefinedNodes().add(loopNode); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(loopNode)); + + ValueSpecificationAction valueSpecificationAction = UML + .createValueSpecificationAction(); + assertValid(valueSpecificationAction); + activityFinalNode.getRedefinedNodes().add(valueSpecificationAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(valueSpecificationAction)); + + AcceptCallAction acceptCallAction = UML.createAcceptCallAction(); + assertValid(acceptCallAction); + activityFinalNode.getRedefinedNodes().add(acceptCallAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(acceptCallAction)); + + AddVariableValueAction addVariableValueAction = UML + .createAddVariableValueAction(); + assertValid(addVariableValueAction); + activityFinalNode.getRedefinedNodes().add(addVariableValueAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(addVariableValueAction)); + + ReadLinkObjectEndAction readLinkObjectEndAction = UML + .createReadLinkObjectEndAction(); + assertValid(readLinkObjectEndAction); + activityFinalNode.getRedefinedNodes().add(readLinkObjectEndAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(readLinkObjectEndAction)); + + UnmarshallAction unmarshallAction = UML.createUnmarshallAction(); + assertValid(unmarshallAction); + activityFinalNode.getRedefinedNodes().add(unmarshallAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(unmarshallAction)); + + OpaqueAction opaqueAction = UML.createOpaqueAction(); + assertValid(opaqueAction); + activityFinalNode.getRedefinedNodes().add(opaqueAction); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(opaqueAction)); + + MergeNode mergeNode = UML.createMergeNode(); + assertValid(mergeNode); + activityFinalNode.getRedefinedNodes().add(mergeNode); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(mergeNode)); + + SequenceNode sequenceNode = UML.createSequenceNode(); + assertValid(sequenceNode); + activityFinalNode.getRedefinedNodes().add(sequenceNode); + assertSuperset( + activityFinalNode.getRedefinedElements().contains(sequenceNode)); + + CreateObjectAction createObjectAction = UML.createCreateObjectAction(); + assertValid(createObjectAction); + activityFinalNode.getRedefinedNodes().add(createObjectAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(createObjectAction)); + + DestroyObjectAction destroyObjectAction = UML + .createDestroyObjectAction(); + assertValid(destroyObjectAction); + activityFinalNode.getRedefinedNodes().add(destroyObjectAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(destroyObjectAction)); + + ReadStructuralFeatureAction readStructuralFeatureAction = UML + .createReadStructuralFeatureAction(); + assertValid(readStructuralFeatureAction); + activityFinalNode.getRedefinedNodes().add(readStructuralFeatureAction); + assertSuperset(activityFinalNode.getRedefinedElements() + .contains(readStructuralFeatureAction)); + } + + public void testInPartition() { + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + + ActivityPartition activityPartition = UML.createActivityPartition(); + assertValid(activityPartition); + activityFinalNode.getInPartitions().add(activityPartition); + assertSuperset( + activityFinalNode.getInGroups().contains(activityPartition)); + } + +} |