diff options
Diffstat (limited to 'cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ValuePinTest.java')
| -rwxr-xr-x | cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ValuePinTest.java | 1234 |
1 files changed, 1234 insertions, 0 deletions
diff --git a/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ValuePinTest.java b/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ValuePinTest.java new file mode 100755 index 00000000..01ccbd07 --- /dev/null +++ b/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ValuePinTest.java @@ -0,0 +1,1234 @@ +/* + * 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.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.Duration; +import org.eclipse.uml2.uml.DurationInterval; +import org.eclipse.uml2.uml.Element; +import org.eclipse.uml2.uml.Enumeration; +import org.eclipse.uml2.uml.ExecutionEnvironment; +import org.eclipse.uml2.uml.ExpansionNode; +import org.eclipse.uml2.uml.ExpansionRegion; +import org.eclipse.uml2.uml.Expression; +import org.eclipse.uml2.uml.Extension; +import org.eclipse.uml2.uml.FinalState; +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.InstanceValue; +import org.eclipse.uml2.uml.Interaction; +import org.eclipse.uml2.uml.Interface; +import org.eclipse.uml2.uml.InterruptibleActivityRegion; +import org.eclipse.uml2.uml.Interval; +import org.eclipse.uml2.uml.JoinNode; +import org.eclipse.uml2.uml.LiteralBoolean; +import org.eclipse.uml2.uml.LiteralInteger; +import org.eclipse.uml2.uml.LiteralNull; +import org.eclipse.uml2.uml.LiteralReal; +import org.eclipse.uml2.uml.LiteralString; +import org.eclipse.uml2.uml.LiteralUnlimitedNatural; +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.OpaqueExpression; +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.State; +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.TimeExpression; +import org.eclipse.uml2.uml.TimeInterval; +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 ValuePinTest + extends _Abstract_Compliance_Test_ { + + public void testEAnnotations() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + EAnnotation eAnnotation = ECORE.createEAnnotation(); + assertValid(eAnnotation); + valuePin.getEAnnotations().add(eAnnotation); + } + + public void testOwnedComment() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + Comment comment = UML.createComment(); + assertValid(comment); + valuePin.getOwnedComments().add(comment); + assertSuperset(valuePin.getOwnedElements().contains(comment)); + } + + public void testOwnedElement() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + EList<Element> elements = valuePin.getOwnedElements(); + EList<Element> elements2 = valuePin.getOwnedElements(); + assertSame(elements, elements2); + } + + public void testClientDependency() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + EList<Dependency> dependencys = valuePin.getClientDependencies(); + EList<Dependency> dependencys2 = valuePin.getClientDependencies(); + assertSame(dependencys, dependencys2); + } + + public void testNameExpression() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + StringExpression stringExpression = UML.createStringExpression(); + assertValid(stringExpression); + valuePin.setNameExpression(stringExpression); + assertSuperset(valuePin.getOwnedElements().contains(stringExpression)); + } + + public void testRedefinedElement() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + EList<RedefinableElement> redefinableElements = valuePin + .getRedefinedElements(); + EList<RedefinableElement> redefinableElements2 = valuePin + .getRedefinedElements(); + assertSame(redefinableElements, redefinableElements2); + } + + public void testRedefinitionContext() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + EList<Classifier> classifiers = valuePin.getRedefinitionContexts(); + EList<Classifier> classifiers2 = valuePin.getRedefinitionContexts(); + assertSame(classifiers, classifiers2); + } + + public void testInGroup() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + EList<ActivityGroup> activityGroups = valuePin.getInGroups(); + EList<ActivityGroup> activityGroups2 = valuePin.getInGroups(); + assertSame(activityGroups, activityGroups2); + } + + public void testInInterruptibleRegion() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + InterruptibleActivityRegion interruptibleActivityRegion = UML + .createInterruptibleActivityRegion(); + assertValid(interruptibleActivityRegion); + valuePin.getInInterruptibleRegions().add(interruptibleActivityRegion); + assertSuperset( + valuePin.getInGroups().contains(interruptibleActivityRegion)); + } + + public void testInStructuredNode() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + LoopNode loopNode = UML.createLoopNode(); + assertValid(loopNode); + valuePin.setInStructuredNode(loopNode); + assertSuperset(valuePin.getInGroups().contains(loopNode)); + assertSuperset(valuePin.getOwner() == loopNode); + + ExpansionRegion expansionRegion = UML.createExpansionRegion(); + assertValid(expansionRegion); + valuePin.setInStructuredNode(expansionRegion); + assertSuperset(valuePin.getInGroups().contains(expansionRegion)); + assertSuperset(valuePin.getOwner() == expansionRegion); + + ValuePin valuePin2 = UML.createValuePin(); + assertValid(valuePin2); + + StructuredActivityNode structuredActivityNode = UML + .createStructuredActivityNode(); + assertValid(structuredActivityNode); + valuePin2.setInStructuredNode(structuredActivityNode); + assertSuperset( + valuePin2.getInGroups().contains(structuredActivityNode)); + assertSuperset(valuePin2.getOwner() == structuredActivityNode); + + ConditionalNode conditionalNode = UML.createConditionalNode(); + assertValid(conditionalNode); + valuePin2.setInStructuredNode(conditionalNode); + assertSuperset(valuePin2.getInGroups().contains(conditionalNode)); + assertSuperset(valuePin2.getOwner() == conditionalNode); + } + + public void testIncoming() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + ControlFlow controlFlow = UML.createControlFlow(); + assertValid(controlFlow); + valuePin.getIncomings().add(controlFlow); + + ObjectFlow objectFlow = UML.createObjectFlow(); + assertValid(objectFlow); + valuePin.getIncomings().add(objectFlow); + } + + public void testOutgoing() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + ControlFlow controlFlow = UML.createControlFlow(); + assertValid(controlFlow); + valuePin.getOutgoings().add(controlFlow); + + ObjectFlow objectFlow = UML.createObjectFlow(); + assertValid(objectFlow); + valuePin.getOutgoings().add(objectFlow); + } + + public void testRedefinedNode() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + StartClassifierBehaviorAction startClassifierBehaviorAction = UML + .createStartClassifierBehaviorAction(); + assertValid(startClassifierBehaviorAction); + valuePin.getRedefinedNodes().add(startClassifierBehaviorAction); + assertSuperset(valuePin.getRedefinedElements() + .contains(startClassifierBehaviorAction)); + + RemoveVariableValueAction removeVariableValueAction = UML + .createRemoveVariableValueAction(); + assertValid(removeVariableValueAction); + valuePin.getRedefinedNodes().add(removeVariableValueAction); + assertSuperset(valuePin.getRedefinedElements() + .contains(removeVariableValueAction)); + + ReadSelfAction readSelfAction = UML.createReadSelfAction(); + assertValid(readSelfAction); + valuePin.getRedefinedNodes().add(readSelfAction); + assertSuperset( + valuePin.getRedefinedElements().contains(readSelfAction)); + + InputPin inputPin = UML.createInputPin(); + assertValid(inputPin); + valuePin.getRedefinedNodes().add(inputPin); + assertSuperset(valuePin.getRedefinedElements().contains(inputPin)); + + ReadLinkObjectEndQualifierAction readLinkObjectEndQualifierAction = UML + .createReadLinkObjectEndQualifierAction(); + assertValid(readLinkObjectEndQualifierAction); + valuePin.getRedefinedNodes().add(readLinkObjectEndQualifierAction); + assertSuperset(valuePin.getRedefinedElements() + .contains(readLinkObjectEndQualifierAction)); + + JoinNode joinNode = UML.createJoinNode(); + assertValid(joinNode); + valuePin.getRedefinedNodes().add(joinNode); + assertSuperset(valuePin.getRedefinedElements().contains(joinNode)); + + CreateLinkObjectAction createLinkObjectAction = UML + .createCreateLinkObjectAction(); + assertValid(createLinkObjectAction); + valuePin.getRedefinedNodes().add(createLinkObjectAction); + assertSuperset( + valuePin.getRedefinedElements().contains(createLinkObjectAction)); + + SendSignalAction sendSignalAction = UML.createSendSignalAction(); + assertValid(sendSignalAction); + valuePin.getRedefinedNodes().add(sendSignalAction); + assertSuperset( + valuePin.getRedefinedElements().contains(sendSignalAction)); + + ReadLinkAction readLinkAction = UML.createReadLinkAction(); + assertValid(readLinkAction); + valuePin.getRedefinedNodes().add(readLinkAction); + assertSuperset( + valuePin.getRedefinedElements().contains(readLinkAction)); + + ReplyAction replyAction = UML.createReplyAction(); + assertValid(replyAction); + valuePin.getRedefinedNodes().add(replyAction); + assertSuperset(valuePin.getRedefinedElements().contains(replyAction)); + + ClearAssociationAction clearAssociationAction = UML + .createClearAssociationAction(); + assertValid(clearAssociationAction); + valuePin.getRedefinedNodes().add(clearAssociationAction); + assertSuperset( + valuePin.getRedefinedElements().contains(clearAssociationAction)); + + FlowFinalNode flowFinalNode = UML.createFlowFinalNode(); + assertValid(flowFinalNode); + valuePin.getRedefinedNodes().add(flowFinalNode); + assertSuperset(valuePin.getRedefinedElements().contains(flowFinalNode)); + + ClearStructuralFeatureAction clearStructuralFeatureAction = UML + .createClearStructuralFeatureAction(); + assertValid(clearStructuralFeatureAction); + valuePin.getRedefinedNodes().add(clearStructuralFeatureAction); + assertSuperset(valuePin.getRedefinedElements() + .contains(clearStructuralFeatureAction)); + + ExpansionRegion expansionRegion = UML.createExpansionRegion(); + assertValid(expansionRegion); + valuePin.getRedefinedNodes().add(expansionRegion); + assertSuperset( + valuePin.getRedefinedElements().contains(expansionRegion)); + + StructuredActivityNode structuredActivityNode = UML + .createStructuredActivityNode(); + assertValid(structuredActivityNode); + valuePin.getRedefinedNodes().add(structuredActivityNode); + assertSuperset( + valuePin.getRedefinedElements().contains(structuredActivityNode)); + + ValuePin valuePin2 = UML.createValuePin(); + assertValid(valuePin2); + valuePin.getRedefinedNodes().add(valuePin2); + assertSuperset(valuePin.getRedefinedElements().contains(valuePin2)); + + StartObjectBehaviorAction startObjectBehaviorAction = UML + .createStartObjectBehaviorAction(); + assertValid(startObjectBehaviorAction); + valuePin.getRedefinedNodes().add(startObjectBehaviorAction); + assertSuperset(valuePin.getRedefinedElements() + .contains(startObjectBehaviorAction)); + + ForkNode forkNode = UML.createForkNode(); + assertValid(forkNode); + valuePin.getRedefinedNodes().add(forkNode); + assertSuperset(valuePin.getRedefinedElements().contains(forkNode)); + + DecisionNode decisionNode = UML.createDecisionNode(); + assertValid(decisionNode); + valuePin.getRedefinedNodes().add(decisionNode); + assertSuperset(valuePin.getRedefinedElements().contains(decisionNode)); + + CallBehaviorAction callBehaviorAction = UML.createCallBehaviorAction(); + assertValid(callBehaviorAction); + valuePin.getRedefinedNodes().add(callBehaviorAction); + assertSuperset( + valuePin.getRedefinedElements().contains(callBehaviorAction)); + + ConditionalNode conditionalNode = UML.createConditionalNode(); + assertValid(conditionalNode); + valuePin.getRedefinedNodes().add(conditionalNode); + assertSuperset( + valuePin.getRedefinedElements().contains(conditionalNode)); + + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + valuePin.getRedefinedNodes().add(readExtentAction); + assertSuperset( + valuePin.getRedefinedElements().contains(readExtentAction)); + + ActionInputPin actionInputPin = UML.createActionInputPin(); + assertValid(actionInputPin); + valuePin.getRedefinedNodes().add(actionInputPin); + assertSuperset( + valuePin.getRedefinedElements().contains(actionInputPin)); + + ReadIsClassifiedObjectAction readIsClassifiedObjectAction = UML + .createReadIsClassifiedObjectAction(); + assertValid(readIsClassifiedObjectAction); + valuePin.getRedefinedNodes().add(readIsClassifiedObjectAction); + assertSuperset(valuePin.getRedefinedElements() + .contains(readIsClassifiedObjectAction)); + + ActivityParameterNode activityParameterNode = UML + .createActivityParameterNode(); + assertValid(activityParameterNode); + valuePin.getRedefinedNodes().add(activityParameterNode); + assertSuperset( + valuePin.getRedefinedElements().contains(activityParameterNode)); + + AddStructuralFeatureValueAction addStructuralFeatureValueAction = UML + .createAddStructuralFeatureValueAction(); + assertValid(addStructuralFeatureValueAction); + valuePin.getRedefinedNodes().add(addStructuralFeatureValueAction); + assertSuperset(valuePin.getRedefinedElements() + .contains(addStructuralFeatureValueAction)); + + ReadVariableAction readVariableAction = UML.createReadVariableAction(); + assertValid(readVariableAction); + valuePin.getRedefinedNodes().add(readVariableAction); + assertSuperset( + valuePin.getRedefinedElements().contains(readVariableAction)); + + ClearVariableAction clearVariableAction = UML + .createClearVariableAction(); + assertValid(clearVariableAction); + valuePin.getRedefinedNodes().add(clearVariableAction); + assertSuperset( + valuePin.getRedefinedElements().contains(clearVariableAction)); + + RemoveStructuralFeatureValueAction removeStructuralFeatureValueAction = UML + .createRemoveStructuralFeatureValueAction(); + assertValid(removeStructuralFeatureValueAction); + valuePin.getRedefinedNodes().add(removeStructuralFeatureValueAction); + assertSuperset(valuePin.getRedefinedElements() + .contains(removeStructuralFeatureValueAction)); + + CreateLinkAction createLinkAction = UML.createCreateLinkAction(); + assertValid(createLinkAction); + valuePin.getRedefinedNodes().add(createLinkAction); + assertSuperset( + valuePin.getRedefinedElements().contains(createLinkAction)); + + ReclassifyObjectAction reclassifyObjectAction = UML + .createReclassifyObjectAction(); + assertValid(reclassifyObjectAction); + valuePin.getRedefinedNodes().add(reclassifyObjectAction); + assertSuperset( + valuePin.getRedefinedElements().contains(reclassifyObjectAction)); + + DataStoreNode dataStoreNode = UML.createDataStoreNode(); + assertValid(dataStoreNode); + valuePin.getRedefinedNodes().add(dataStoreNode); + assertSuperset(valuePin.getRedefinedElements().contains(dataStoreNode)); + + SendObjectAction sendObjectAction = UML.createSendObjectAction(); + assertValid(sendObjectAction); + valuePin.getRedefinedNodes().add(sendObjectAction); + assertSuperset( + valuePin.getRedefinedElements().contains(sendObjectAction)); + + ReduceAction reduceAction = UML.createReduceAction(); + assertValid(reduceAction); + valuePin.getRedefinedNodes().add(reduceAction); + assertSuperset(valuePin.getRedefinedElements().contains(reduceAction)); + + AcceptEventAction acceptEventAction = UML.createAcceptEventAction(); + assertValid(acceptEventAction); + valuePin.getRedefinedNodes().add(acceptEventAction); + assertSuperset( + valuePin.getRedefinedElements().contains(acceptEventAction)); + + DestroyLinkAction destroyLinkAction = UML.createDestroyLinkAction(); + assertValid(destroyLinkAction); + valuePin.getRedefinedNodes().add(destroyLinkAction); + assertSuperset( + valuePin.getRedefinedElements().contains(destroyLinkAction)); + + ExpansionNode expansionNode = UML.createExpansionNode(); + assertValid(expansionNode); + valuePin.getRedefinedNodes().add(expansionNode); + assertSuperset(valuePin.getRedefinedElements().contains(expansionNode)); + + InitialNode initialNode = UML.createInitialNode(); + assertValid(initialNode); + valuePin.getRedefinedNodes().add(initialNode); + assertSuperset(valuePin.getRedefinedElements().contains(initialNode)); + + TestIdentityAction testIdentityAction = UML.createTestIdentityAction(); + assertValid(testIdentityAction); + valuePin.getRedefinedNodes().add(testIdentityAction); + assertSuperset( + valuePin.getRedefinedElements().contains(testIdentityAction)); + + OutputPin outputPin = UML.createOutputPin(); + assertValid(outputPin); + valuePin.getRedefinedNodes().add(outputPin); + assertSuperset(valuePin.getRedefinedElements().contains(outputPin)); + + CentralBufferNode centralBufferNode = UML.createCentralBufferNode(); + assertValid(centralBufferNode); + valuePin.getRedefinedNodes().add(centralBufferNode); + assertSuperset( + valuePin.getRedefinedElements().contains(centralBufferNode)); + + BroadcastSignalAction broadcastSignalAction = UML + .createBroadcastSignalAction(); + assertValid(broadcastSignalAction); + valuePin.getRedefinedNodes().add(broadcastSignalAction); + assertSuperset( + valuePin.getRedefinedElements().contains(broadcastSignalAction)); + + RaiseExceptionAction raiseExceptionAction = UML + .createRaiseExceptionAction(); + assertValid(raiseExceptionAction); + valuePin.getRedefinedNodes().add(raiseExceptionAction); + assertSuperset( + valuePin.getRedefinedElements().contains(raiseExceptionAction)); + + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + valuePin.getRedefinedNodes().add(activityFinalNode); + assertSuperset( + valuePin.getRedefinedElements().contains(activityFinalNode)); + + CallOperationAction callOperationAction = UML + .createCallOperationAction(); + assertValid(callOperationAction); + valuePin.getRedefinedNodes().add(callOperationAction); + assertSuperset( + valuePin.getRedefinedElements().contains(callOperationAction)); + + LoopNode loopNode = UML.createLoopNode(); + assertValid(loopNode); + valuePin.getRedefinedNodes().add(loopNode); + assertSuperset(valuePin.getRedefinedElements().contains(loopNode)); + + ValueSpecificationAction valueSpecificationAction = UML + .createValueSpecificationAction(); + assertValid(valueSpecificationAction); + valuePin.getRedefinedNodes().add(valueSpecificationAction); + assertSuperset( + valuePin.getRedefinedElements().contains(valueSpecificationAction)); + + AcceptCallAction acceptCallAction = UML.createAcceptCallAction(); + assertValid(acceptCallAction); + valuePin.getRedefinedNodes().add(acceptCallAction); + assertSuperset( + valuePin.getRedefinedElements().contains(acceptCallAction)); + + AddVariableValueAction addVariableValueAction = UML + .createAddVariableValueAction(); + assertValid(addVariableValueAction); + valuePin.getRedefinedNodes().add(addVariableValueAction); + assertSuperset( + valuePin.getRedefinedElements().contains(addVariableValueAction)); + + ReadLinkObjectEndAction readLinkObjectEndAction = UML + .createReadLinkObjectEndAction(); + assertValid(readLinkObjectEndAction); + valuePin.getRedefinedNodes().add(readLinkObjectEndAction); + assertSuperset( + valuePin.getRedefinedElements().contains(readLinkObjectEndAction)); + + UnmarshallAction unmarshallAction = UML.createUnmarshallAction(); + assertValid(unmarshallAction); + valuePin.getRedefinedNodes().add(unmarshallAction); + assertSuperset( + valuePin.getRedefinedElements().contains(unmarshallAction)); + + OpaqueAction opaqueAction = UML.createOpaqueAction(); + assertValid(opaqueAction); + valuePin.getRedefinedNodes().add(opaqueAction); + assertSuperset(valuePin.getRedefinedElements().contains(opaqueAction)); + + MergeNode mergeNode = UML.createMergeNode(); + assertValid(mergeNode); + valuePin.getRedefinedNodes().add(mergeNode); + assertSuperset(valuePin.getRedefinedElements().contains(mergeNode)); + + SequenceNode sequenceNode = UML.createSequenceNode(); + assertValid(sequenceNode); + valuePin.getRedefinedNodes().add(sequenceNode); + assertSuperset(valuePin.getRedefinedElements().contains(sequenceNode)); + + CreateObjectAction createObjectAction = UML.createCreateObjectAction(); + assertValid(createObjectAction); + valuePin.getRedefinedNodes().add(createObjectAction); + assertSuperset( + valuePin.getRedefinedElements().contains(createObjectAction)); + + DestroyObjectAction destroyObjectAction = UML + .createDestroyObjectAction(); + assertValid(destroyObjectAction); + valuePin.getRedefinedNodes().add(destroyObjectAction); + assertSuperset( + valuePin.getRedefinedElements().contains(destroyObjectAction)); + + ReadStructuralFeatureAction readStructuralFeatureAction = UML + .createReadStructuralFeatureAction(); + assertValid(readStructuralFeatureAction); + valuePin.getRedefinedNodes().add(readStructuralFeatureAction); + assertSuperset(valuePin.getRedefinedElements() + .contains(readStructuralFeatureAction)); + } + + public void testInPartition() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + ActivityPartition activityPartition = UML.createActivityPartition(); + assertValid(activityPartition); + valuePin.getInPartitions().add(activityPartition); + assertSuperset(valuePin.getInGroups().contains(activityPartition)); + } + + public void testType() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + FunctionBehavior functionBehavior = UML.createFunctionBehavior(); + assertValid(functionBehavior); + valuePin.setType(functionBehavior); + + Activity activity = UML.createActivity(); + assertValid(activity); + valuePin.setType(activity); + + ValuePin valuePin2 = UML.createValuePin(); + assertValid(valuePin2); + + Interface interface_ = UML.createInterface(); + assertValid(interface_); + valuePin2.setType(interface_); + + InformationItem informationItem = UML.createInformationItem(); + assertValid(informationItem); + valuePin2.setType(informationItem); + + ValuePin valuePin3 = UML.createValuePin(); + assertValid(valuePin3); + + CommunicationPath communicationPath = UML.createCommunicationPath(); + assertValid(communicationPath); + valuePin3.setType(communicationPath); + + ExecutionEnvironment executionEnvironment = UML + .createExecutionEnvironment(); + assertValid(executionEnvironment); + valuePin3.setType(executionEnvironment); + + ValuePin valuePin4 = UML.createValuePin(); + assertValid(valuePin4); + + Component component = UML.createComponent(); + assertValid(component); + valuePin4.setType(component); + + Interaction interaction = UML.createInteraction(); + assertValid(interaction); + valuePin4.setType(interaction); + + ValuePin valuePin5 = UML.createValuePin(); + assertValid(valuePin5); + + DeploymentSpecification deploymentSpecification = UML + .createDeploymentSpecification(); + assertValid(deploymentSpecification); + valuePin5.setType(deploymentSpecification); + + OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior(); + assertValid(opaqueBehavior); + valuePin5.setType(opaqueBehavior); + + ValuePin valuePin6 = UML.createValuePin(); + assertValid(valuePin6); + + Association association = UML.createAssociation(); + assertValid(association); + valuePin6.setType(association); + + DataType dataType = UML.createDataType(); + assertValid(dataType); + valuePin6.setType(dataType); + + ValuePin valuePin7 = UML.createValuePin(); + assertValid(valuePin7); + + Device device = UML.createDevice(); + assertValid(device); + valuePin7.setType(device); + + Extension extension = UML.createExtension(); + assertValid(extension); + valuePin7.setType(extension); + + ValuePin valuePin8 = UML.createValuePin(); + assertValid(valuePin8); + + AssociationClass associationClass = UML.createAssociationClass(); + assertValid(associationClass); + valuePin8.setType(associationClass); + + org.eclipse.uml2.uml.Class class_ = UML.createClass(); + assertValid(class_); + valuePin8.setType(class_); + + ValuePin valuePin9 = UML.createValuePin(); + assertValid(valuePin9); + + Enumeration enumeration = UML.createEnumeration(); + assertValid(enumeration); + valuePin9.setType(enumeration); + + PrimitiveType primitiveType = UML.createPrimitiveType(); + assertValid(primitiveType); + valuePin9.setType(primitiveType); + + ValuePin valuePin10 = UML.createValuePin(); + assertValid(valuePin10); + + Actor actor = UML.createActor(); + assertValid(actor); + valuePin10.setType(actor); + + ProtocolStateMachine protocolStateMachine = UML + .createProtocolStateMachine(); + assertValid(protocolStateMachine); + valuePin10.setType(protocolStateMachine); + + ValuePin valuePin11 = UML.createValuePin(); + assertValid(valuePin11); + + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + valuePin11.setType(useCase); + + Signal signal = UML.createSignal(); + assertValid(signal); + valuePin11.setType(signal); + + ValuePin valuePin12 = UML.createValuePin(); + assertValid(valuePin12); + + Node node = UML.createNode(); + assertValid(node); + valuePin12.setType(node); + + Stereotype stereotype = UML.createStereotype(); + assertValid(stereotype); + valuePin12.setType(stereotype); + + ValuePin valuePin13 = UML.createValuePin(); + assertValid(valuePin13); + + StateMachine stateMachine = UML.createStateMachine(); + assertValid(stateMachine); + valuePin13.setType(stateMachine); + + Artifact artifact = UML.createArtifact(); + assertValid(artifact); + valuePin13.setType(artifact); + + ValuePin valuePin14 = UML.createValuePin(); + assertValid(valuePin14); + + Collaboration collaboration = UML.createCollaboration(); + assertValid(collaboration); + valuePin14.setType(collaboration); + } + + public void testInState() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + FinalState finalState = UML.createFinalState(); + assertValid(finalState); + valuePin.getInStates().add(finalState); + + State state = UML.createState(); + assertValid(state); + valuePin.getInStates().add(state); + } + + public void testSelection() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + ProtocolStateMachine protocolStateMachine = UML + .createProtocolStateMachine(); + assertValid(protocolStateMachine); + valuePin.setSelection(protocolStateMachine); + + StateMachine stateMachine = UML.createStateMachine(); + assertValid(stateMachine); + valuePin.setSelection(stateMachine); + } + + public void testUpperBound() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + LiteralBoolean literalBoolean = UML.createLiteralBoolean(); + assertValid(literalBoolean); + valuePin.setUpperBound(literalBoolean); + assertSuperset(valuePin.getOwnedElements().contains(literalBoolean)); + + Interval interval = UML.createInterval(); + assertValid(interval); + valuePin.setUpperBound(interval); + assertSuperset(valuePin.getOwnedElements().contains(interval)); + + ValuePin valuePin2 = UML.createValuePin(); + assertValid(valuePin2); + + OpaqueExpression opaqueExpression = UML.createOpaqueExpression(); + assertValid(opaqueExpression); + valuePin2.setUpperBound(opaqueExpression); + assertSuperset(valuePin2.getOwnedElements().contains(opaqueExpression)); + + Expression expression = UML.createExpression(); + assertValid(expression); + valuePin2.setUpperBound(expression); + assertSuperset(valuePin2.getOwnedElements().contains(expression)); + + ValuePin valuePin3 = UML.createValuePin(); + assertValid(valuePin3); + + LiteralReal literalReal = UML.createLiteralReal(); + assertValid(literalReal); + valuePin3.setUpperBound(literalReal); + assertSuperset(valuePin3.getOwnedElements().contains(literalReal)); + + LiteralString literalString = UML.createLiteralString(); + assertValid(literalString); + valuePin3.setUpperBound(literalString); + assertSuperset(valuePin3.getOwnedElements().contains(literalString)); + + ValuePin valuePin4 = UML.createValuePin(); + assertValid(valuePin4); + + LiteralNull literalNull = UML.createLiteralNull(); + assertValid(literalNull); + valuePin4.setUpperBound(literalNull); + assertSuperset(valuePin4.getOwnedElements().contains(literalNull)); + + Duration duration = UML.createDuration(); + assertValid(duration); + valuePin4.setUpperBound(duration); + assertSuperset(valuePin4.getOwnedElements().contains(duration)); + + ValuePin valuePin5 = UML.createValuePin(); + assertValid(valuePin5); + + LiteralInteger literalInteger = UML.createLiteralInteger(); + assertValid(literalInteger); + valuePin5.setUpperBound(literalInteger); + assertSuperset(valuePin5.getOwnedElements().contains(literalInteger)); + + DurationInterval durationInterval = UML.createDurationInterval(); + assertValid(durationInterval); + valuePin5.setUpperBound(durationInterval); + assertSuperset(valuePin5.getOwnedElements().contains(durationInterval)); + + ValuePin valuePin6 = UML.createValuePin(); + assertValid(valuePin6); + + StringExpression stringExpression = UML.createStringExpression(); + assertValid(stringExpression); + valuePin6.setUpperBound(stringExpression); + assertSuperset(valuePin6.getOwnedElements().contains(stringExpression)); + + LiteralUnlimitedNatural literalUnlimitedNatural = UML + .createLiteralUnlimitedNatural(); + assertValid(literalUnlimitedNatural); + valuePin6.setUpperBound(literalUnlimitedNatural); + assertSuperset( + valuePin6.getOwnedElements().contains(literalUnlimitedNatural)); + + ValuePin valuePin7 = UML.createValuePin(); + assertValid(valuePin7); + + TimeInterval timeInterval = UML.createTimeInterval(); + assertValid(timeInterval); + valuePin7.setUpperBound(timeInterval); + assertSuperset(valuePin7.getOwnedElements().contains(timeInterval)); + + TimeExpression timeExpression = UML.createTimeExpression(); + assertValid(timeExpression); + valuePin7.setUpperBound(timeExpression); + assertSuperset(valuePin7.getOwnedElements().contains(timeExpression)); + + ValuePin valuePin8 = UML.createValuePin(); + assertValid(valuePin8); + + InstanceValue instanceValue = UML.createInstanceValue(); + assertValid(instanceValue); + valuePin8.setUpperBound(instanceValue); + assertSuperset(valuePin8.getOwnedElements().contains(instanceValue)); + } + + public void testLowerValue() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + LiteralBoolean literalBoolean = UML.createLiteralBoolean(); + assertValid(literalBoolean); + valuePin.setLowerValue(literalBoolean); + assertSuperset(valuePin.getOwnedElements().contains(literalBoolean)); + + Interval interval = UML.createInterval(); + assertValid(interval); + valuePin.setLowerValue(interval); + assertSuperset(valuePin.getOwnedElements().contains(interval)); + + ValuePin valuePin2 = UML.createValuePin(); + assertValid(valuePin2); + + OpaqueExpression opaqueExpression = UML.createOpaqueExpression(); + assertValid(opaqueExpression); + valuePin2.setLowerValue(opaqueExpression); + assertSuperset(valuePin2.getOwnedElements().contains(opaqueExpression)); + + Expression expression = UML.createExpression(); + assertValid(expression); + valuePin2.setLowerValue(expression); + assertSuperset(valuePin2.getOwnedElements().contains(expression)); + + ValuePin valuePin3 = UML.createValuePin(); + assertValid(valuePin3); + + LiteralReal literalReal = UML.createLiteralReal(); + assertValid(literalReal); + valuePin3.setLowerValue(literalReal); + assertSuperset(valuePin3.getOwnedElements().contains(literalReal)); + + LiteralString literalString = UML.createLiteralString(); + assertValid(literalString); + valuePin3.setLowerValue(literalString); + assertSuperset(valuePin3.getOwnedElements().contains(literalString)); + + ValuePin valuePin4 = UML.createValuePin(); + assertValid(valuePin4); + + LiteralNull literalNull = UML.createLiteralNull(); + assertValid(literalNull); + valuePin4.setLowerValue(literalNull); + assertSuperset(valuePin4.getOwnedElements().contains(literalNull)); + + Duration duration = UML.createDuration(); + assertValid(duration); + valuePin4.setLowerValue(duration); + assertSuperset(valuePin4.getOwnedElements().contains(duration)); + + ValuePin valuePin5 = UML.createValuePin(); + assertValid(valuePin5); + + LiteralInteger literalInteger = UML.createLiteralInteger(); + assertValid(literalInteger); + valuePin5.setLowerValue(literalInteger); + assertSuperset(valuePin5.getOwnedElements().contains(literalInteger)); + + DurationInterval durationInterval = UML.createDurationInterval(); + assertValid(durationInterval); + valuePin5.setLowerValue(durationInterval); + assertSuperset(valuePin5.getOwnedElements().contains(durationInterval)); + + ValuePin valuePin6 = UML.createValuePin(); + assertValid(valuePin6); + + StringExpression stringExpression = UML.createStringExpression(); + assertValid(stringExpression); + valuePin6.setLowerValue(stringExpression); + assertSuperset(valuePin6.getOwnedElements().contains(stringExpression)); + + LiteralUnlimitedNatural literalUnlimitedNatural = UML + .createLiteralUnlimitedNatural(); + assertValid(literalUnlimitedNatural); + valuePin6.setLowerValue(literalUnlimitedNatural); + assertSuperset( + valuePin6.getOwnedElements().contains(literalUnlimitedNatural)); + + ValuePin valuePin7 = UML.createValuePin(); + assertValid(valuePin7); + + TimeInterval timeInterval = UML.createTimeInterval(); + assertValid(timeInterval); + valuePin7.setLowerValue(timeInterval); + assertSuperset(valuePin7.getOwnedElements().contains(timeInterval)); + + TimeExpression timeExpression = UML.createTimeExpression(); + assertValid(timeExpression); + valuePin7.setLowerValue(timeExpression); + assertSuperset(valuePin7.getOwnedElements().contains(timeExpression)); + + ValuePin valuePin8 = UML.createValuePin(); + assertValid(valuePin8); + + InstanceValue instanceValue = UML.createInstanceValue(); + assertValid(instanceValue); + valuePin8.setLowerValue(instanceValue); + assertSuperset(valuePin8.getOwnedElements().contains(instanceValue)); + } + + public void testUpperValue() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + LiteralBoolean literalBoolean = UML.createLiteralBoolean(); + assertValid(literalBoolean); + valuePin.setUpperValue(literalBoolean); + assertSuperset(valuePin.getOwnedElements().contains(literalBoolean)); + + Interval interval = UML.createInterval(); + assertValid(interval); + valuePin.setUpperValue(interval); + assertSuperset(valuePin.getOwnedElements().contains(interval)); + + ValuePin valuePin2 = UML.createValuePin(); + assertValid(valuePin2); + + OpaqueExpression opaqueExpression = UML.createOpaqueExpression(); + assertValid(opaqueExpression); + valuePin2.setUpperValue(opaqueExpression); + assertSuperset(valuePin2.getOwnedElements().contains(opaqueExpression)); + + Expression expression = UML.createExpression(); + assertValid(expression); + valuePin2.setUpperValue(expression); + assertSuperset(valuePin2.getOwnedElements().contains(expression)); + + ValuePin valuePin3 = UML.createValuePin(); + assertValid(valuePin3); + + LiteralReal literalReal = UML.createLiteralReal(); + assertValid(literalReal); + valuePin3.setUpperValue(literalReal); + assertSuperset(valuePin3.getOwnedElements().contains(literalReal)); + + LiteralString literalString = UML.createLiteralString(); + assertValid(literalString); + valuePin3.setUpperValue(literalString); + assertSuperset(valuePin3.getOwnedElements().contains(literalString)); + + ValuePin valuePin4 = UML.createValuePin(); + assertValid(valuePin4); + + LiteralNull literalNull = UML.createLiteralNull(); + assertValid(literalNull); + valuePin4.setUpperValue(literalNull); + assertSuperset(valuePin4.getOwnedElements().contains(literalNull)); + + Duration duration = UML.createDuration(); + assertValid(duration); + valuePin4.setUpperValue(duration); + assertSuperset(valuePin4.getOwnedElements().contains(duration)); + + ValuePin valuePin5 = UML.createValuePin(); + assertValid(valuePin5); + + LiteralInteger literalInteger = UML.createLiteralInteger(); + assertValid(literalInteger); + valuePin5.setUpperValue(literalInteger); + assertSuperset(valuePin5.getOwnedElements().contains(literalInteger)); + + DurationInterval durationInterval = UML.createDurationInterval(); + assertValid(durationInterval); + valuePin5.setUpperValue(durationInterval); + assertSuperset(valuePin5.getOwnedElements().contains(durationInterval)); + + ValuePin valuePin6 = UML.createValuePin(); + assertValid(valuePin6); + + StringExpression stringExpression = UML.createStringExpression(); + assertValid(stringExpression); + valuePin6.setUpperValue(stringExpression); + assertSuperset(valuePin6.getOwnedElements().contains(stringExpression)); + + LiteralUnlimitedNatural literalUnlimitedNatural = UML + .createLiteralUnlimitedNatural(); + assertValid(literalUnlimitedNatural); + valuePin6.setUpperValue(literalUnlimitedNatural); + assertSuperset( + valuePin6.getOwnedElements().contains(literalUnlimitedNatural)); + + ValuePin valuePin7 = UML.createValuePin(); + assertValid(valuePin7); + + TimeInterval timeInterval = UML.createTimeInterval(); + assertValid(timeInterval); + valuePin7.setUpperValue(timeInterval); + assertSuperset(valuePin7.getOwnedElements().contains(timeInterval)); + + TimeExpression timeExpression = UML.createTimeExpression(); + assertValid(timeExpression); + valuePin7.setUpperValue(timeExpression); + assertSuperset(valuePin7.getOwnedElements().contains(timeExpression)); + + ValuePin valuePin8 = UML.createValuePin(); + assertValid(valuePin8); + + InstanceValue instanceValue = UML.createInstanceValue(); + assertValid(instanceValue); + valuePin8.setUpperValue(instanceValue); + assertSuperset(valuePin8.getOwnedElements().contains(instanceValue)); + } + + public void testValue() { + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + + LiteralBoolean literalBoolean = UML.createLiteralBoolean(); + assertValid(literalBoolean); + valuePin.setValue(literalBoolean); + assertSuperset(valuePin.getOwnedElements().contains(literalBoolean)); + + Interval interval = UML.createInterval(); + assertValid(interval); + valuePin.setValue(interval); + assertSuperset(valuePin.getOwnedElements().contains(interval)); + + ValuePin valuePin2 = UML.createValuePin(); + assertValid(valuePin2); + + OpaqueExpression opaqueExpression = UML.createOpaqueExpression(); + assertValid(opaqueExpression); + valuePin2.setValue(opaqueExpression); + assertSuperset(valuePin2.getOwnedElements().contains(opaqueExpression)); + + Expression expression = UML.createExpression(); + assertValid(expression); + valuePin2.setValue(expression); + assertSuperset(valuePin2.getOwnedElements().contains(expression)); + + ValuePin valuePin3 = UML.createValuePin(); + assertValid(valuePin3); + + LiteralReal literalReal = UML.createLiteralReal(); + assertValid(literalReal); + valuePin3.setValue(literalReal); + assertSuperset(valuePin3.getOwnedElements().contains(literalReal)); + + LiteralString literalString = UML.createLiteralString(); + assertValid(literalString); + valuePin3.setValue(literalString); + assertSuperset(valuePin3.getOwnedElements().contains(literalString)); + + ValuePin valuePin4 = UML.createValuePin(); + assertValid(valuePin4); + + LiteralNull literalNull = UML.createLiteralNull(); + assertValid(literalNull); + valuePin4.setValue(literalNull); + assertSuperset(valuePin4.getOwnedElements().contains(literalNull)); + + Duration duration = UML.createDuration(); + assertValid(duration); + valuePin4.setValue(duration); + assertSuperset(valuePin4.getOwnedElements().contains(duration)); + + ValuePin valuePin5 = UML.createValuePin(); + assertValid(valuePin5); + + LiteralInteger literalInteger = UML.createLiteralInteger(); + assertValid(literalInteger); + valuePin5.setValue(literalInteger); + assertSuperset(valuePin5.getOwnedElements().contains(literalInteger)); + + DurationInterval durationInterval = UML.createDurationInterval(); + assertValid(durationInterval); + valuePin5.setValue(durationInterval); + assertSuperset(valuePin5.getOwnedElements().contains(durationInterval)); + + ValuePin valuePin6 = UML.createValuePin(); + assertValid(valuePin6); + + StringExpression stringExpression = UML.createStringExpression(); + assertValid(stringExpression); + valuePin6.setValue(stringExpression); + assertSuperset(valuePin6.getOwnedElements().contains(stringExpression)); + + LiteralUnlimitedNatural literalUnlimitedNatural = UML + .createLiteralUnlimitedNatural(); + assertValid(literalUnlimitedNatural); + valuePin6.setValue(literalUnlimitedNatural); + assertSuperset( + valuePin6.getOwnedElements().contains(literalUnlimitedNatural)); + + ValuePin valuePin7 = UML.createValuePin(); + assertValid(valuePin7); + + TimeInterval timeInterval = UML.createTimeInterval(); + assertValid(timeInterval); + valuePin7.setValue(timeInterval); + assertSuperset(valuePin7.getOwnedElements().contains(timeInterval)); + + TimeExpression timeExpression = UML.createTimeExpression(); + assertValid(timeExpression); + valuePin7.setValue(timeExpression); + assertSuperset(valuePin7.getOwnedElements().contains(timeExpression)); + + ValuePin valuePin8 = UML.createValuePin(); + assertValid(valuePin8); + + InstanceValue instanceValue = UML.createInstanceValue(); + assertValid(instanceValue); + valuePin8.setValue(instanceValue); + assertSuperset(valuePin8.getOwnedElements().contains(instanceValue)); + } + +} |