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