diff options
Diffstat (limited to 'cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/DependencyTest.java')
| -rwxr-xr-x | cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/DependencyTest.java | 2133 |
1 files changed, 2133 insertions, 0 deletions
diff --git a/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/DependencyTest.java b/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/DependencyTest.java new file mode 100755 index 00000000..88071b0d --- /dev/null +++ b/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/DependencyTest.java @@ -0,0 +1,2133 @@ +/* + * 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.Abstraction; +import org.eclipse.uml2.uml.AcceptCallAction; +import org.eclipse.uml2.uml.AcceptEventAction; +import org.eclipse.uml2.uml.ActionExecutionSpecification; +import org.eclipse.uml2.uml.ActionInputPin; +import org.eclipse.uml2.uml.Activity; +import org.eclipse.uml2.uml.ActivityFinalNode; +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.AnyReceiveEvent; +import org.eclipse.uml2.uml.Artifact; +import org.eclipse.uml2.uml.Association; +import org.eclipse.uml2.uml.AssociationClass; +import org.eclipse.uml2.uml.BehaviorExecutionSpecification; +import org.eclipse.uml2.uml.BroadcastSignalAction; +import org.eclipse.uml2.uml.CallBehaviorAction; +import org.eclipse.uml2.uml.CallEvent; +import org.eclipse.uml2.uml.CallOperationAction; +import org.eclipse.uml2.uml.CentralBufferNode; +import org.eclipse.uml2.uml.ChangeEvent; +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.CollaborationUse; +import org.eclipse.uml2.uml.CombinedFragment; +import org.eclipse.uml2.uml.Comment; +import org.eclipse.uml2.uml.CommunicationPath; +import org.eclipse.uml2.uml.Component; +import org.eclipse.uml2.uml.ComponentRealization; +import org.eclipse.uml2.uml.ConditionalNode; +import org.eclipse.uml2.uml.ConnectionPointReference; +import org.eclipse.uml2.uml.Connector; +import org.eclipse.uml2.uml.ConsiderIgnoreFragment; +import org.eclipse.uml2.uml.Constraint; +import org.eclipse.uml2.uml.Continuation; +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.Deployment; +import org.eclipse.uml2.uml.DeploymentSpecification; +import org.eclipse.uml2.uml.DestroyLinkAction; +import org.eclipse.uml2.uml.DestroyObjectAction; +import org.eclipse.uml2.uml.DestructionOccurrenceSpecification; +import org.eclipse.uml2.uml.Device; +import org.eclipse.uml2.uml.Duration; +import org.eclipse.uml2.uml.DurationConstraint; +import org.eclipse.uml2.uml.DurationInterval; +import org.eclipse.uml2.uml.DurationObservation; +import org.eclipse.uml2.uml.Element; +import org.eclipse.uml2.uml.Enumeration; +import org.eclipse.uml2.uml.EnumerationLiteral; +import org.eclipse.uml2.uml.ExecutionEnvironment; +import org.eclipse.uml2.uml.ExecutionOccurrenceSpecification; +import org.eclipse.uml2.uml.ExpansionNode; +import org.eclipse.uml2.uml.ExpansionRegion; +import org.eclipse.uml2.uml.Expression; +import org.eclipse.uml2.uml.Extend; +import org.eclipse.uml2.uml.Extension; +import org.eclipse.uml2.uml.ExtensionEnd; +import org.eclipse.uml2.uml.ExtensionPoint; +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.Gate; +import org.eclipse.uml2.uml.GeneralOrdering; +import org.eclipse.uml2.uml.GeneralizationSet; +import org.eclipse.uml2.uml.Include; +import org.eclipse.uml2.uml.InformationFlow; +import org.eclipse.uml2.uml.InformationItem; +import org.eclipse.uml2.uml.InitialNode; +import org.eclipse.uml2.uml.InputPin; +import org.eclipse.uml2.uml.InstanceSpecification; +import org.eclipse.uml2.uml.InstanceValue; +import org.eclipse.uml2.uml.Interaction; +import org.eclipse.uml2.uml.InteractionConstraint; +import org.eclipse.uml2.uml.InteractionOperand; +import org.eclipse.uml2.uml.InteractionUse; +import org.eclipse.uml2.uml.Interface; +import org.eclipse.uml2.uml.InterfaceRealization; +import org.eclipse.uml2.uml.InterruptibleActivityRegion; +import org.eclipse.uml2.uml.Interval; +import org.eclipse.uml2.uml.IntervalConstraint; +import org.eclipse.uml2.uml.JoinNode; +import org.eclipse.uml2.uml.Lifeline; +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.Manifestation; +import org.eclipse.uml2.uml.MergeNode; +import org.eclipse.uml2.uml.Message; +import org.eclipse.uml2.uml.MessageOccurrenceSpecification; +import org.eclipse.uml2.uml.Model; +import org.eclipse.uml2.uml.Node; +import org.eclipse.uml2.uml.ObjectFlow; +import org.eclipse.uml2.uml.OccurrenceSpecification; +import org.eclipse.uml2.uml.OpaqueAction; +import org.eclipse.uml2.uml.OpaqueBehavior; +import org.eclipse.uml2.uml.OpaqueExpression; +import org.eclipse.uml2.uml.Operation; +import org.eclipse.uml2.uml.OutputPin; +import org.eclipse.uml2.uml.Parameter; +import org.eclipse.uml2.uml.ParameterSet; +import org.eclipse.uml2.uml.PartDecomposition; +import org.eclipse.uml2.uml.Port; +import org.eclipse.uml2.uml.PrimitiveType; +import org.eclipse.uml2.uml.Profile; +import org.eclipse.uml2.uml.Property; +import org.eclipse.uml2.uml.ProtocolStateMachine; +import org.eclipse.uml2.uml.ProtocolTransition; +import org.eclipse.uml2.uml.Pseudostate; +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.Realization; +import org.eclipse.uml2.uml.Reception; +import org.eclipse.uml2.uml.ReclassifyObjectAction; +import org.eclipse.uml2.uml.RedefinableTemplateSignature; +import org.eclipse.uml2.uml.ReduceAction; +import org.eclipse.uml2.uml.Region; +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.SignalEvent; +import org.eclipse.uml2.uml.StartClassifierBehaviorAction; +import org.eclipse.uml2.uml.StartObjectBehaviorAction; +import org.eclipse.uml2.uml.State; +import org.eclipse.uml2.uml.StateInvariant; +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.Substitution; +import org.eclipse.uml2.uml.TemplateParameter; +import org.eclipse.uml2.uml.TestIdentityAction; +import org.eclipse.uml2.uml.TimeConstraint; +import org.eclipse.uml2.uml.TimeEvent; +import org.eclipse.uml2.uml.TimeExpression; +import org.eclipse.uml2.uml.TimeInterval; +import org.eclipse.uml2.uml.TimeObservation; +import org.eclipse.uml2.uml.Transition; +import org.eclipse.uml2.uml.Trigger; +import org.eclipse.uml2.uml.UnmarshallAction; +import org.eclipse.uml2.uml.Usage; +import org.eclipse.uml2.uml.UseCase; +import org.eclipse.uml2.uml.ValuePin; +import org.eclipse.uml2.uml.ValueSpecificationAction; +import org.eclipse.uml2.uml.Variable; + +/** + * @author Eike Stepper + */ +public class DependencyTest + extends _Abstract_Compliance_Test_ { + + public void testEAnnotations() { + Dependency dependency = UML.createDependency(); + assertValid(dependency); + + EAnnotation eAnnotation = ECORE.createEAnnotation(); + assertValid(eAnnotation); + dependency.getEAnnotations().add(eAnnotation); + } + + public void testOwnedComment() { + Dependency dependency = UML.createDependency(); + assertValid(dependency); + + Comment comment = UML.createComment(); + assertValid(comment); + dependency.getOwnedComments().add(comment); + assertSuperset(dependency.getOwnedElements().contains(comment)); + } + + public void testOwnedElement() { + Dependency dependency = UML.createDependency(); + assertValid(dependency); + EList<Element> elements = dependency.getOwnedElements(); + EList<Element> elements2 = dependency.getOwnedElements(); + assertSame(elements, elements2); + } + + public void testClientDependency() { + Dependency dependency = UML.createDependency(); + assertValid(dependency); + EList<Dependency> dependencys2 = dependency.getClientDependencies(); + EList<Dependency> dependencys3 = dependency.getClientDependencies(); + assertSame(dependencys2, dependencys3); + } + + public void testNameExpression() { + Dependency dependency = UML.createDependency(); + assertValid(dependency); + + StringExpression stringExpression = UML.createStringExpression(); + assertValid(stringExpression); + dependency.setNameExpression(stringExpression); + assertSuperset( + dependency.getOwnedElements().contains(stringExpression)); + } + + public void testOwningTemplateParameter() { + Dependency dependency = UML.createDependency(); + assertValid(dependency); + + TemplateParameter templateParameter = UML.createTemplateParameter(); + assertValid(templateParameter); + dependency.setOwningTemplateParameter(templateParameter); + assertSuperset(dependency.getOwner() == templateParameter); + assertSuperset(dependency.getTemplateParameter() == templateParameter); + } + + public void testTemplateParameter() { + Dependency dependency = UML.createDependency(); + assertValid(dependency); + + TemplateParameter templateParameter = UML.createTemplateParameter(); + assertValid(templateParameter); + dependency.setTemplateParameter(templateParameter); + } + + public void testRelatedElement() { + Dependency dependency = UML.createDependency(); + assertValid(dependency); + EList<Element> elements = dependency.getRelatedElements(); + EList<Element> elements2 = dependency.getRelatedElements(); + assertSame(elements, elements2); + } + + public void testSource() { + Dependency dependency = UML.createDependency(); + assertValid(dependency); + EList<Element> elements = dependency.getSources(); + EList<Element> elements2 = dependency.getSources(); + assertSame(elements, elements2); + } + + public void testTarget() { + Dependency dependency = UML.createDependency(); + assertValid(dependency); + EList<Element> elements = dependency.getTargets(); + EList<Element> elements2 = dependency.getTargets(); + assertSame(elements, elements2); + } + + public void testClient() { + Dependency dependency = UML.createDependency(); + assertValid(dependency); + + Activity activity = UML.createActivity(); + assertValid(activity); + dependency.getClients().add(activity); + assertSuperset(dependency.getSources().contains(activity)); + + CommunicationPath communicationPath = UML.createCommunicationPath(); + assertValid(communicationPath); + dependency.getClients().add(communicationPath); + assertSuperset(dependency.getSources().contains(communicationPath)); + + ReadSelfAction readSelfAction = UML.createReadSelfAction(); + assertValid(readSelfAction); + dependency.getClients().add(readSelfAction); + assertSuperset(dependency.getSources().contains(readSelfAction)); + + ActivityPartition activityPartition = UML.createActivityPartition(); + assertValid(activityPartition); + dependency.getClients().add(activityPartition); + assertSuperset(dependency.getSources().contains(activityPartition)); + + InputPin inputPin = UML.createInputPin(); + assertValid(inputPin); + dependency.getClients().add(inputPin); + assertSuperset(dependency.getSources().contains(inputPin)); + + ReadLinkObjectEndQualifierAction readLinkObjectEndQualifierAction = UML + .createReadLinkObjectEndQualifierAction(); + assertValid(readLinkObjectEndQualifierAction); + dependency.getClients().add(readLinkObjectEndQualifierAction); + assertSuperset( + dependency.getSources().contains(readLinkObjectEndQualifierAction)); + + Component component = UML.createComponent(); + assertValid(component); + dependency.getClients().add(component); + assertSuperset(dependency.getSources().contains(component)); + + Manifestation manifestation = UML.createManifestation(); + assertValid(manifestation); + dependency.getClients().add(manifestation); + assertSuperset(dependency.getSources().contains(manifestation)); + + DurationObservation durationObservation = UML + .createDurationObservation(); + assertValid(durationObservation); + dependency.getClients().add(durationObservation); + assertSuperset(dependency.getSources().contains(durationObservation)); + + CallEvent callEvent = UML.createCallEvent(); + assertValid(callEvent); + dependency.getClients().add(callEvent); + assertSuperset(dependency.getSources().contains(callEvent)); + + JoinNode joinNode = UML.createJoinNode(); + assertValid(joinNode); + dependency.getClients().add(joinNode); + assertSuperset(dependency.getSources().contains(joinNode)); + + Interaction interaction = UML.createInteraction(); + assertValid(interaction); + dependency.getClients().add(interaction); + assertSuperset(dependency.getSources().contains(interaction)); + + CreateLinkObjectAction createLinkObjectAction = UML + .createCreateLinkObjectAction(); + assertValid(createLinkObjectAction); + dependency.getClients().add(createLinkObjectAction); + assertSuperset( + dependency.getSources().contains(createLinkObjectAction)); + + OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior(); + assertValid(opaqueBehavior); + dependency.getClients().add(opaqueBehavior); + assertSuperset(dependency.getSources().contains(opaqueBehavior)); + + LiteralUnlimitedNatural literalUnlimitedNatural = UML + .createLiteralUnlimitedNatural(); + assertValid(literalUnlimitedNatural); + dependency.getClients().add(literalUnlimitedNatural); + assertSuperset( + dependency.getSources().contains(literalUnlimitedNatural)); + + SendSignalAction sendSignalAction = UML.createSendSignalAction(); + assertValid(sendSignalAction); + dependency.getClients().add(sendSignalAction); + assertSuperset(dependency.getSources().contains(sendSignalAction)); + + ReadLinkAction readLinkAction = UML.createReadLinkAction(); + assertValid(readLinkAction); + dependency.getClients().add(readLinkAction); + assertSuperset(dependency.getSources().contains(readLinkAction)); + + Operation operation = UML.createOperation(); + assertValid(operation); + dependency.getClients().add(operation); + assertSuperset(dependency.getSources().contains(operation)); + + ClearAssociationAction clearAssociationAction = UML + .createClearAssociationAction(); + assertValid(clearAssociationAction); + dependency.getClients().add(clearAssociationAction); + assertSuperset( + dependency.getSources().contains(clearAssociationAction)); + + Model model = UML.createModel(); + assertValid(model); + dependency.getClients().add(model); + assertSuperset(dependency.getSources().contains(model)); + + Parameter parameter = UML.createParameter(); + assertValid(parameter); + dependency.getClients().add(parameter); + assertSuperset(dependency.getSources().contains(parameter)); + + InstanceValue instanceValue = UML.createInstanceValue(); + assertValid(instanceValue); + dependency.getClients().add(instanceValue); + assertSuperset(dependency.getSources().contains(instanceValue)); + + Trigger trigger = UML.createTrigger(); + assertValid(trigger); + dependency.getClients().add(trigger); + assertSuperset(dependency.getSources().contains(trigger)); + + InteractionConstraint interactionConstraint = UML + .createInteractionConstraint(); + assertValid(interactionConstraint); + dependency.getClients().add(interactionConstraint); + assertSuperset(dependency.getSources().contains(interactionConstraint)); + + AssociationClass associationClass = UML.createAssociationClass(); + assertValid(associationClass); + dependency.getClients().add(associationClass); + assertSuperset(dependency.getSources().contains(associationClass)); + + InteractionUse interactionUse = UML.createInteractionUse(); + assertValid(interactionUse); + dependency.getClients().add(interactionUse); + assertSuperset(dependency.getSources().contains(interactionUse)); + + ClearStructuralFeatureAction clearStructuralFeatureAction = UML + .createClearStructuralFeatureAction(); + assertValid(clearStructuralFeatureAction); + dependency.getClients().add(clearStructuralFeatureAction); + assertSuperset( + dependency.getSources().contains(clearStructuralFeatureAction)); + + Interval interval = UML.createInterval(); + assertValid(interval); + dependency.getClients().add(interval); + assertSuperset(dependency.getSources().contains(interval)); + + StructuredActivityNode structuredActivityNode = UML + .createStructuredActivityNode(); + assertValid(structuredActivityNode); + dependency.getClients().add(structuredActivityNode); + assertSuperset( + dependency.getSources().contains(structuredActivityNode)); + + LiteralString literalString = UML.createLiteralString(); + assertValid(literalString); + dependency.getClients().add(literalString); + assertSuperset(dependency.getSources().contains(literalString)); + + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + dependency.getClients().add(valuePin); + assertSuperset(dependency.getSources().contains(valuePin)); + + InterfaceRealization interfaceRealization = UML + .createInterfaceRealization(); + assertValid(interfaceRealization); + dependency.getClients().add(interfaceRealization); + assertSuperset(dependency.getSources().contains(interfaceRealization)); + + ForkNode forkNode = UML.createForkNode(); + assertValid(forkNode); + dependency.getClients().add(forkNode); + assertSuperset(dependency.getSources().contains(forkNode)); + + DecisionNode decisionNode = UML.createDecisionNode(); + assertValid(decisionNode); + dependency.getClients().add(decisionNode); + assertSuperset(dependency.getSources().contains(decisionNode)); + + Actor actor = UML.createActor(); + assertValid(actor); + dependency.getClients().add(actor); + assertSuperset(dependency.getSources().contains(actor)); + + TimeConstraint timeConstraint = UML.createTimeConstraint(); + assertValid(timeConstraint); + dependency.getClients().add(timeConstraint); + assertSuperset(dependency.getSources().contains(timeConstraint)); + + Reception reception = UML.createReception(); + assertValid(reception); + dependency.getClients().add(reception); + assertSuperset(dependency.getSources().contains(reception)); + + Pseudostate pseudostate = UML.createPseudostate(); + assertValid(pseudostate); + dependency.getClients().add(pseudostate); + assertSuperset(dependency.getSources().contains(pseudostate)); + + DurationInterval durationInterval = UML.createDurationInterval(); + assertValid(durationInterval); + dependency.getClients().add(durationInterval); + assertSuperset(dependency.getSources().contains(durationInterval)); + + Deployment deployment = UML.createDeployment(); + assertValid(deployment); + dependency.getClients().add(deployment); + assertSuperset(dependency.getSources().contains(deployment)); + + ExtensionEnd extensionEnd = UML.createExtensionEnd(); + assertValid(extensionEnd); + dependency.getClients().add(extensionEnd); + assertSuperset(dependency.getSources().contains(extensionEnd)); + + ConsiderIgnoreFragment considerIgnoreFragment = UML + .createConsiderIgnoreFragment(); + assertValid(considerIgnoreFragment); + dependency.getClients().add(considerIgnoreFragment); + assertSuperset( + dependency.getSources().contains(considerIgnoreFragment)); + + ConditionalNode conditionalNode = UML.createConditionalNode(); + assertValid(conditionalNode); + dependency.getClients().add(conditionalNode); + assertSuperset(dependency.getSources().contains(conditionalNode)); + + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + dependency.getClients().add(readExtentAction); + assertSuperset(dependency.getSources().contains(readExtentAction)); + + ActionInputPin actionInputPin = UML.createActionInputPin(); + assertValid(actionInputPin); + dependency.getClients().add(actionInputPin); + assertSuperset(dependency.getSources().contains(actionInputPin)); + + Artifact artifact = UML.createArtifact(); + assertValid(artifact); + dependency.getClients().add(artifact); + assertSuperset(dependency.getSources().contains(artifact)); + + InformationFlow informationFlow = UML.createInformationFlow(); + assertValid(informationFlow); + dependency.getClients().add(informationFlow); + assertSuperset(dependency.getSources().contains(informationFlow)); + + ClearVariableAction clearVariableAction = UML + .createClearVariableAction(); + assertValid(clearVariableAction); + dependency.getClients().add(clearVariableAction); + assertSuperset(dependency.getSources().contains(clearVariableAction)); + + CreateLinkAction createLinkAction = UML.createCreateLinkAction(); + assertValid(createLinkAction); + dependency.getClients().add(createLinkAction); + assertSuperset(dependency.getSources().contains(createLinkAction)); + + SignalEvent signalEvent = UML.createSignalEvent(); + assertValid(signalEvent); + dependency.getClients().add(signalEvent); + assertSuperset(dependency.getSources().contains(signalEvent)); + + ConnectionPointReference connectionPointReference = UML + .createConnectionPointReference(); + assertValid(connectionPointReference); + dependency.getClients().add(connectionPointReference); + assertSuperset( + dependency.getSources().contains(connectionPointReference)); + + ReclassifyObjectAction reclassifyObjectAction = UML + .createReclassifyObjectAction(); + assertValid(reclassifyObjectAction); + dependency.getClients().add(reclassifyObjectAction); + assertSuperset( + dependency.getSources().contains(reclassifyObjectAction)); + + Usage usage = UML.createUsage(); + assertValid(usage); + dependency.getClients().add(usage); + assertSuperset(dependency.getSources().contains(usage)); + + DataStoreNode dataStoreNode = UML.createDataStoreNode(); + assertValid(dataStoreNode); + dependency.getClients().add(dataStoreNode); + assertSuperset(dependency.getSources().contains(dataStoreNode)); + + ExecutionEnvironment executionEnvironment = UML + .createExecutionEnvironment(); + assertValid(executionEnvironment); + dependency.getClients().add(executionEnvironment); + assertSuperset(dependency.getSources().contains(executionEnvironment)); + + SendObjectAction sendObjectAction = UML.createSendObjectAction(); + assertValid(sendObjectAction); + dependency.getClients().add(sendObjectAction); + assertSuperset(dependency.getSources().contains(sendObjectAction)); + + ControlFlow controlFlow = UML.createControlFlow(); + assertValid(controlFlow); + dependency.getClients().add(controlFlow); + assertSuperset(dependency.getSources().contains(controlFlow)); + + DeploymentSpecification deploymentSpecification = UML + .createDeploymentSpecification(); + assertValid(deploymentSpecification); + dependency.getClients().add(deploymentSpecification); + assertSuperset( + dependency.getSources().contains(deploymentSpecification)); + + PartDecomposition partDecomposition = UML.createPartDecomposition(); + assertValid(partDecomposition); + dependency.getClients().add(partDecomposition); + assertSuperset(dependency.getSources().contains(partDecomposition)); + + DestroyLinkAction destroyLinkAction = UML.createDestroyLinkAction(); + assertValid(destroyLinkAction); + dependency.getClients().add(destroyLinkAction); + assertSuperset(dependency.getSources().contains(destroyLinkAction)); + + Realization realization = UML.createRealization(); + assertValid(realization); + dependency.getClients().add(realization); + assertSuperset(dependency.getSources().contains(realization)); + + ExpansionNode expansionNode = UML.createExpansionNode(); + assertValid(expansionNode); + dependency.getClients().add(expansionNode); + assertSuperset(dependency.getSources().contains(expansionNode)); + + TestIdentityAction testIdentityAction = UML.createTestIdentityAction(); + assertValid(testIdentityAction); + dependency.getClients().add(testIdentityAction); + assertSuperset(dependency.getSources().contains(testIdentityAction)); + + Association association = UML.createAssociation(); + assertValid(association); + dependency.getClients().add(association); + assertSuperset(dependency.getSources().contains(association)); + + TimeInterval timeInterval = UML.createTimeInterval(); + assertValid(timeInterval); + dependency.getClients().add(timeInterval); + assertSuperset(dependency.getSources().contains(timeInterval)); + + DataType dataType = UML.createDataType(); + assertValid(dataType); + dependency.getClients().add(dataType); + assertSuperset(dependency.getSources().contains(dataType)); + + OutputPin outputPin = UML.createOutputPin(); + assertValid(outputPin); + dependency.getClients().add(outputPin); + assertSuperset(dependency.getSources().contains(outputPin)); + + Substitution substitution = UML.createSubstitution(); + assertValid(substitution); + dependency.getClients().add(substitution); + assertSuperset(dependency.getSources().contains(substitution)); + + Include include = UML.createInclude(); + assertValid(include); + dependency.getClients().add(include); + assertSuperset(dependency.getSources().contains(include)); + + Extend extend = UML.createExtend(); + assertValid(extend); + dependency.getClients().add(extend); + assertSuperset(dependency.getSources().contains(extend)); + + BroadcastSignalAction broadcastSignalAction = UML + .createBroadcastSignalAction(); + assertValid(broadcastSignalAction); + dependency.getClients().add(broadcastSignalAction); + assertSuperset(dependency.getSources().contains(broadcastSignalAction)); + + LiteralBoolean literalBoolean = UML.createLiteralBoolean(); + assertValid(literalBoolean); + dependency.getClients().add(literalBoolean); + assertSuperset(dependency.getSources().contains(literalBoolean)); + + FinalState finalState = UML.createFinalState(); + assertValid(finalState); + dependency.getClients().add(finalState); + assertSuperset(dependency.getSources().contains(finalState)); + + RaiseExceptionAction raiseExceptionAction = UML + .createRaiseExceptionAction(); + assertValid(raiseExceptionAction); + dependency.getClients().add(raiseExceptionAction); + assertSuperset(dependency.getSources().contains(raiseExceptionAction)); + + DurationConstraint durationConstraint = UML.createDurationConstraint(); + assertValid(durationConstraint); + dependency.getClients().add(durationConstraint); + assertSuperset(dependency.getSources().contains(durationConstraint)); + + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + dependency.getClients().add(activityFinalNode); + assertSuperset(dependency.getSources().contains(activityFinalNode)); + + LiteralNull literalNull = UML.createLiteralNull(); + assertValid(literalNull); + dependency.getClients().add(literalNull); + assertSuperset(dependency.getSources().contains(literalNull)); + + CallOperationAction callOperationAction = UML + .createCallOperationAction(); + assertValid(callOperationAction); + dependency.getClients().add(callOperationAction); + assertSuperset(dependency.getSources().contains(callOperationAction)); + + ProtocolStateMachine protocolStateMachine = UML + .createProtocolStateMachine(); + assertValid(protocolStateMachine); + dependency.getClients().add(protocolStateMachine); + assertSuperset(dependency.getSources().contains(protocolStateMachine)); + + LoopNode loopNode = UML.createLoopNode(); + assertValid(loopNode); + dependency.getClients().add(loopNode); + assertSuperset(dependency.getSources().contains(loopNode)); + + ParameterSet parameterSet = UML.createParameterSet(); + assertValid(parameterSet); + dependency.getClients().add(parameterSet); + assertSuperset(dependency.getSources().contains(parameterSet)); + + ValueSpecificationAction valueSpecificationAction = UML + .createValueSpecificationAction(); + assertValid(valueSpecificationAction); + dependency.getClients().add(valueSpecificationAction); + assertSuperset( + dependency.getSources().contains(valueSpecificationAction)); + + Node node = UML.createNode(); + assertValid(node); + dependency.getClients().add(node); + assertSuperset(dependency.getSources().contains(node)); + + SequenceNode sequenceNode = UML.createSequenceNode(); + assertValid(sequenceNode); + dependency.getClients().add(sequenceNode); + assertSuperset(dependency.getSources().contains(sequenceNode)); + + Constraint constraint = UML.createConstraint(); + assertValid(constraint); + dependency.getClients().add(constraint); + assertSuperset(dependency.getSources().contains(constraint)); + + DestroyObjectAction destroyObjectAction = UML + .createDestroyObjectAction(); + assertValid(destroyObjectAction); + dependency.getClients().add(destroyObjectAction); + assertSuperset(dependency.getSources().contains(destroyObjectAction)); + + StateMachine stateMachine = UML.createStateMachine(); + assertValid(stateMachine); + dependency.getClients().add(stateMachine); + assertSuperset(dependency.getSources().contains(stateMachine)); + + EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral); + dependency.getClients().add(enumerationLiteral); + assertSuperset(dependency.getSources().contains(enumerationLiteral)); + + ActionExecutionSpecification actionExecutionSpecification = UML + .createActionExecutionSpecification(); + assertValid(actionExecutionSpecification); + dependency.getClients().add(actionExecutionSpecification); + assertSuperset( + dependency.getSources().contains(actionExecutionSpecification)); + + FunctionBehavior functionBehavior = UML.createFunctionBehavior(); + assertValid(functionBehavior); + dependency.getClients().add(functionBehavior); + assertSuperset(dependency.getSources().contains(functionBehavior)); + + Interface interface_ = UML.createInterface(); + assertValid(interface_); + dependency.getClients().add(interface_); + assertSuperset(dependency.getSources().contains(interface_)); + + InstanceSpecification instanceSpecification = UML + .createInstanceSpecification(); + assertValid(instanceSpecification); + dependency.getClients().add(instanceSpecification); + assertSuperset(dependency.getSources().contains(instanceSpecification)); + + StartClassifierBehaviorAction startClassifierBehaviorAction = UML + .createStartClassifierBehaviorAction(); + assertValid(startClassifierBehaviorAction); + dependency.getClients().add(startClassifierBehaviorAction); + assertSuperset( + dependency.getSources().contains(startClassifierBehaviorAction)); + + Port port = UML.createPort(); + assertValid(port); + dependency.getClients().add(port); + assertSuperset(dependency.getSources().contains(port)); + + RemoveVariableValueAction removeVariableValueAction = UML + .createRemoveVariableValueAction(); + assertValid(removeVariableValueAction); + dependency.getClients().add(removeVariableValueAction); + assertSuperset( + dependency.getSources().contains(removeVariableValueAction)); + + InformationItem informationItem = UML.createInformationItem(); + assertValid(informationItem); + dependency.getClients().add(informationItem); + assertSuperset(dependency.getSources().contains(informationItem)); + + LiteralReal literalReal = UML.createLiteralReal(); + assertValid(literalReal); + dependency.getClients().add(literalReal); + assertSuperset(dependency.getSources().contains(literalReal)); + + RedefinableTemplateSignature redefinableTemplateSignature = UML + .createRedefinableTemplateSignature(); + assertValid(redefinableTemplateSignature); + dependency.getClients().add(redefinableTemplateSignature); + assertSuperset( + dependency.getSources().contains(redefinableTemplateSignature)); + + ExecutionOccurrenceSpecification executionOccurrenceSpecification = UML + .createExecutionOccurrenceSpecification(); + assertValid(executionOccurrenceSpecification); + dependency.getClients().add(executionOccurrenceSpecification); + assertSuperset( + dependency.getSources().contains(executionOccurrenceSpecification)); + + Duration duration = UML.createDuration(); + assertValid(duration); + dependency.getClients().add(duration); + assertSuperset(dependency.getSources().contains(duration)); + + org.eclipse.uml2.uml.Package package_ = UML.createPackage(); + assertValid(package_); + dependency.getClients().add(package_); + assertSuperset(dependency.getSources().contains(package_)); + + Variable variable = UML.createVariable(); + assertValid(variable); + dependency.getClients().add(variable); + assertSuperset(dependency.getSources().contains(variable)); + + DestructionOccurrenceSpecification destructionOccurrenceSpecification = UML + .createDestructionOccurrenceSpecification(); + assertValid(destructionOccurrenceSpecification); + dependency.getClients().add(destructionOccurrenceSpecification); + assertSuperset(dependency.getSources() + .contains(destructionOccurrenceSpecification)); + + Lifeline lifeline = UML.createLifeline(); + assertValid(lifeline); + dependency.getClients().add(lifeline); + assertSuperset(dependency.getSources().contains(lifeline)); + + TimeObservation timeObservation = UML.createTimeObservation(); + assertValid(timeObservation); + dependency.getClients().add(timeObservation); + assertSuperset(dependency.getSources().contains(timeObservation)); + + ReplyAction replyAction = UML.createReplyAction(); + assertValid(replyAction); + dependency.getClients().add(replyAction); + assertSuperset(dependency.getSources().contains(replyAction)); + + Gate gate = UML.createGate(); + assertValid(gate); + dependency.getClients().add(gate); + assertSuperset(dependency.getSources().contains(gate)); + + Property property = UML.createProperty(); + assertValid(property); + dependency.getClients().add(property); + assertSuperset(dependency.getSources().contains(property)); + + TimeExpression timeExpression = UML.createTimeExpression(); + assertValid(timeExpression); + dependency.getClients().add(timeExpression); + assertSuperset(dependency.getSources().contains(timeExpression)); + + Device device = UML.createDevice(); + assertValid(device); + dependency.getClients().add(device); + assertSuperset(dependency.getSources().contains(device)); + + FlowFinalNode flowFinalNode = UML.createFlowFinalNode(); + assertValid(flowFinalNode); + dependency.getClients().add(flowFinalNode); + assertSuperset(dependency.getSources().contains(flowFinalNode)); + + ExpansionRegion expansionRegion = UML.createExpansionRegion(); + assertValid(expansionRegion); + dependency.getClients().add(expansionRegion); + assertSuperset(dependency.getSources().contains(expansionRegion)); + + Abstraction abstraction = UML.createAbstraction(); + assertValid(abstraction); + dependency.getClients().add(abstraction); + assertSuperset(dependency.getSources().contains(abstraction)); + + StartObjectBehaviorAction startObjectBehaviorAction = UML + .createStartObjectBehaviorAction(); + assertValid(startObjectBehaviorAction); + dependency.getClients().add(startObjectBehaviorAction); + assertSuperset( + dependency.getSources().contains(startObjectBehaviorAction)); + + Enumeration enumeration = UML.createEnumeration(); + assertValid(enumeration); + dependency.getClients().add(enumeration); + assertSuperset(dependency.getSources().contains(enumeration)); + + PrimitiveType primitiveType = UML.createPrimitiveType(); + assertValid(primitiveType); + dependency.getClients().add(primitiveType); + assertSuperset(dependency.getSources().contains(primitiveType)); + + Profile profile = UML.createProfile(); + assertValid(profile); + dependency.getClients().add(profile); + assertSuperset(dependency.getSources().contains(profile)); + + Message message = UML.createMessage(); + assertValid(message); + dependency.getClients().add(message); + assertSuperset(dependency.getSources().contains(message)); + + GeneralizationSet generalizationSet = UML.createGeneralizationSet(); + assertValid(generalizationSet); + dependency.getClients().add(generalizationSet); + assertSuperset(dependency.getSources().contains(generalizationSet)); + + Continuation continuation = UML.createContinuation(); + assertValid(continuation); + dependency.getClients().add(continuation); + assertSuperset(dependency.getSources().contains(continuation)); + + Signal signal = UML.createSignal(); + assertValid(signal); + dependency.getClients().add(signal); + assertSuperset(dependency.getSources().contains(signal)); + + CallBehaviorAction callBehaviorAction = UML.createCallBehaviorAction(); + assertValid(callBehaviorAction); + dependency.getClients().add(callBehaviorAction); + assertSuperset(dependency.getSources().contains(callBehaviorAction)); + + ObjectFlow objectFlow = UML.createObjectFlow(); + assertValid(objectFlow); + dependency.getClients().add(objectFlow); + assertSuperset(dependency.getSources().contains(objectFlow)); + + StateInvariant stateInvariant = UML.createStateInvariant(); + assertValid(stateInvariant); + dependency.getClients().add(stateInvariant); + assertSuperset(dependency.getSources().contains(stateInvariant)); + + ReadIsClassifiedObjectAction readIsClassifiedObjectAction = UML + .createReadIsClassifiedObjectAction(); + assertValid(readIsClassifiedObjectAction); + dependency.getClients().add(readIsClassifiedObjectAction); + assertSuperset( + dependency.getSources().contains(readIsClassifiedObjectAction)); + + ActivityParameterNode activityParameterNode = UML + .createActivityParameterNode(); + assertValid(activityParameterNode); + dependency.getClients().add(activityParameterNode); + assertSuperset(dependency.getSources().contains(activityParameterNode)); + + AddStructuralFeatureValueAction addStructuralFeatureValueAction = UML + .createAddStructuralFeatureValueAction(); + assertValid(addStructuralFeatureValueAction); + dependency.getClients().add(addStructuralFeatureValueAction); + assertSuperset( + dependency.getSources().contains(addStructuralFeatureValueAction)); + + ReadVariableAction readVariableAction = UML.createReadVariableAction(); + assertValid(readVariableAction); + dependency.getClients().add(readVariableAction); + assertSuperset(dependency.getSources().contains(readVariableAction)); + + InterruptibleActivityRegion interruptibleActivityRegion = UML + .createInterruptibleActivityRegion(); + assertValid(interruptibleActivityRegion); + dependency.getClients().add(interruptibleActivityRegion); + assertSuperset( + dependency.getSources().contains(interruptibleActivityRegion)); + + RemoveStructuralFeatureValueAction removeStructuralFeatureValueAction = UML + .createRemoveStructuralFeatureValueAction(); + assertValid(removeStructuralFeatureValueAction); + dependency.getClients().add(removeStructuralFeatureValueAction); + assertSuperset(dependency.getSources() + .contains(removeStructuralFeatureValueAction)); + + OpaqueExpression opaqueExpression = UML.createOpaqueExpression(); + assertValid(opaqueExpression); + dependency.getClients().add(opaqueExpression); + assertSuperset(dependency.getSources().contains(opaqueExpression)); + + TimeEvent timeEvent = UML.createTimeEvent(); + assertValid(timeEvent); + dependency.getClients().add(timeEvent); + assertSuperset(dependency.getSources().contains(timeEvent)); + + GeneralOrdering generalOrdering = UML.createGeneralOrdering(); + assertValid(generalOrdering); + dependency.getClients().add(generalOrdering); + assertSuperset(dependency.getSources().contains(generalOrdering)); + + Region region = UML.createRegion(); + assertValid(region); + dependency.getClients().add(region); + assertSuperset(dependency.getSources().contains(region)); + + Transition transition = UML.createTransition(); + assertValid(transition); + dependency.getClients().add(transition); + assertSuperset(dependency.getSources().contains(transition)); + + AnyReceiveEvent anyReceiveEvent = UML.createAnyReceiveEvent(); + assertValid(anyReceiveEvent); + dependency.getClients().add(anyReceiveEvent); + assertSuperset(dependency.getSources().contains(anyReceiveEvent)); + + MessageOccurrenceSpecification messageOccurrenceSpecification = UML + .createMessageOccurrenceSpecification(); + assertValid(messageOccurrenceSpecification); + dependency.getClients().add(messageOccurrenceSpecification); + assertSuperset( + dependency.getSources().contains(messageOccurrenceSpecification)); + + LiteralInteger literalInteger = UML.createLiteralInteger(); + assertValid(literalInteger); + dependency.getClients().add(literalInteger); + assertSuperset(dependency.getSources().contains(literalInteger)); + + ReduceAction reduceAction = UML.createReduceAction(); + assertValid(reduceAction); + dependency.getClients().add(reduceAction); + assertSuperset(dependency.getSources().contains(reduceAction)); + + AcceptEventAction acceptEventAction = UML.createAcceptEventAction(); + assertValid(acceptEventAction); + dependency.getClients().add(acceptEventAction); + assertSuperset(dependency.getSources().contains(acceptEventAction)); + + InitialNode initialNode = UML.createInitialNode(); + assertValid(initialNode); + dependency.getClients().add(initialNode); + assertSuperset(dependency.getSources().contains(initialNode)); + + CentralBufferNode centralBufferNode = UML.createCentralBufferNode(); + assertValid(centralBufferNode); + dependency.getClients().add(centralBufferNode); + assertSuperset(dependency.getSources().contains(centralBufferNode)); + + CombinedFragment combinedFragment = UML.createCombinedFragment(); + assertValid(combinedFragment); + dependency.getClients().add(combinedFragment); + assertSuperset(dependency.getSources().contains(combinedFragment)); + + IntervalConstraint intervalConstraint = UML.createIntervalConstraint(); + assertValid(intervalConstraint); + dependency.getClients().add(intervalConstraint); + assertSuperset(dependency.getSources().contains(intervalConstraint)); + + Extension extension = UML.createExtension(); + assertValid(extension); + dependency.getClients().add(extension); + assertSuperset(dependency.getSources().contains(extension)); + + OccurrenceSpecification occurrenceSpecification = UML + .createOccurrenceSpecification(); + assertValid(occurrenceSpecification); + dependency.getClients().add(occurrenceSpecification); + assertSuperset( + dependency.getSources().contains(occurrenceSpecification)); + + ExtensionPoint extensionPoint = UML.createExtensionPoint(); + assertValid(extensionPoint); + dependency.getClients().add(extensionPoint); + assertSuperset(dependency.getSources().contains(extensionPoint)); + + Dependency dependency2 = UML.createDependency(); + assertValid(dependency2); + dependency.getClients().add(dependency2); + assertSuperset(dependency.getSources().contains(dependency2)); + + Connector connector = UML.createConnector(); + assertValid(connector); + dependency.getClients().add(connector); + assertSuperset(dependency.getSources().contains(connector)); + + Expression expression = UML.createExpression(); + assertValid(expression); + dependency.getClients().add(expression); + assertSuperset(dependency.getSources().contains(expression)); + + ComponentRealization componentRealization = UML + .createComponentRealization(); + assertValid(componentRealization); + dependency.getClients().add(componentRealization); + assertSuperset(dependency.getSources().contains(componentRealization)); + + org.eclipse.uml2.uml.Class class_ = UML.createClass(); + assertValid(class_); + dependency.getClients().add(class_); + assertSuperset(dependency.getSources().contains(class_)); + + State state = UML.createState(); + assertValid(state); + dependency.getClients().add(state); + assertSuperset(dependency.getSources().contains(state)); + + ProtocolTransition protocolTransition = UML.createProtocolTransition(); + assertValid(protocolTransition); + dependency.getClients().add(protocolTransition); + assertSuperset(dependency.getSources().contains(protocolTransition)); + + BehaviorExecutionSpecification behaviorExecutionSpecification = UML + .createBehaviorExecutionSpecification(); + assertValid(behaviorExecutionSpecification); + dependency.getClients().add(behaviorExecutionSpecification); + assertSuperset( + dependency.getSources().contains(behaviorExecutionSpecification)); + + CollaborationUse collaborationUse = UML.createCollaborationUse(); + assertValid(collaborationUse); + dependency.getClients().add(collaborationUse); + assertSuperset(dependency.getSources().contains(collaborationUse)); + + InteractionOperand interactionOperand = UML.createInteractionOperand(); + assertValid(interactionOperand); + dependency.getClients().add(interactionOperand); + assertSuperset(dependency.getSources().contains(interactionOperand)); + + AcceptCallAction acceptCallAction = UML.createAcceptCallAction(); + assertValid(acceptCallAction); + dependency.getClients().add(acceptCallAction); + assertSuperset(dependency.getSources().contains(acceptCallAction)); + + AddVariableValueAction addVariableValueAction = UML + .createAddVariableValueAction(); + assertValid(addVariableValueAction); + dependency.getClients().add(addVariableValueAction); + assertSuperset( + dependency.getSources().contains(addVariableValueAction)); + + ReadLinkObjectEndAction readLinkObjectEndAction = UML + .createReadLinkObjectEndAction(); + assertValid(readLinkObjectEndAction); + dependency.getClients().add(readLinkObjectEndAction); + assertSuperset( + dependency.getSources().contains(readLinkObjectEndAction)); + + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + dependency.getClients().add(useCase); + assertSuperset(dependency.getSources().contains(useCase)); + + UnmarshallAction unmarshallAction = UML.createUnmarshallAction(); + assertValid(unmarshallAction); + dependency.getClients().add(unmarshallAction); + assertSuperset(dependency.getSources().contains(unmarshallAction)); + + OpaqueAction opaqueAction = UML.createOpaqueAction(); + assertValid(opaqueAction); + dependency.getClients().add(opaqueAction); + assertSuperset(dependency.getSources().contains(opaqueAction)); + + StringExpression stringExpression = UML.createStringExpression(); + assertValid(stringExpression); + dependency.getClients().add(stringExpression); + assertSuperset(dependency.getSources().contains(stringExpression)); + + MergeNode mergeNode = UML.createMergeNode(); + assertValid(mergeNode); + dependency.getClients().add(mergeNode); + assertSuperset(dependency.getSources().contains(mergeNode)); + + ChangeEvent changeEvent = UML.createChangeEvent(); + assertValid(changeEvent); + dependency.getClients().add(changeEvent); + assertSuperset(dependency.getSources().contains(changeEvent)); + + CreateObjectAction createObjectAction = UML.createCreateObjectAction(); + assertValid(createObjectAction); + dependency.getClients().add(createObjectAction); + assertSuperset(dependency.getSources().contains(createObjectAction)); + + Stereotype stereotype = UML.createStereotype(); + assertValid(stereotype); + dependency.getClients().add(stereotype); + assertSuperset(dependency.getSources().contains(stereotype)); + + ReadStructuralFeatureAction readStructuralFeatureAction = UML + .createReadStructuralFeatureAction(); + assertValid(readStructuralFeatureAction); + dependency.getClients().add(readStructuralFeatureAction); + assertSuperset( + dependency.getSources().contains(readStructuralFeatureAction)); + + Collaboration collaboration = UML.createCollaboration(); + assertValid(collaboration); + dependency.getClients().add(collaboration); + assertSuperset(dependency.getSources().contains(collaboration)); + } + + public void testSupplier() { + Dependency dependency = UML.createDependency(); + assertValid(dependency); + + Activity activity = UML.createActivity(); + assertValid(activity); + dependency.getSuppliers().add(activity); + assertSuperset(dependency.getTargets().contains(activity)); + + CommunicationPath communicationPath = UML.createCommunicationPath(); + assertValid(communicationPath); + dependency.getSuppliers().add(communicationPath); + assertSuperset(dependency.getTargets().contains(communicationPath)); + + ReadSelfAction readSelfAction = UML.createReadSelfAction(); + assertValid(readSelfAction); + dependency.getSuppliers().add(readSelfAction); + assertSuperset(dependency.getTargets().contains(readSelfAction)); + + ActivityPartition activityPartition = UML.createActivityPartition(); + assertValid(activityPartition); + dependency.getSuppliers().add(activityPartition); + assertSuperset(dependency.getTargets().contains(activityPartition)); + + InputPin inputPin = UML.createInputPin(); + assertValid(inputPin); + dependency.getSuppliers().add(inputPin); + assertSuperset(dependency.getTargets().contains(inputPin)); + + ReadLinkObjectEndQualifierAction readLinkObjectEndQualifierAction = UML + .createReadLinkObjectEndQualifierAction(); + assertValid(readLinkObjectEndQualifierAction); + dependency.getSuppliers().add(readLinkObjectEndQualifierAction); + assertSuperset( + dependency.getTargets().contains(readLinkObjectEndQualifierAction)); + + Component component = UML.createComponent(); + assertValid(component); + dependency.getSuppliers().add(component); + assertSuperset(dependency.getTargets().contains(component)); + + Manifestation manifestation = UML.createManifestation(); + assertValid(manifestation); + dependency.getSuppliers().add(manifestation); + assertSuperset(dependency.getTargets().contains(manifestation)); + + DurationObservation durationObservation = UML + .createDurationObservation(); + assertValid(durationObservation); + dependency.getSuppliers().add(durationObservation); + assertSuperset(dependency.getTargets().contains(durationObservation)); + + CallEvent callEvent = UML.createCallEvent(); + assertValid(callEvent); + dependency.getSuppliers().add(callEvent); + assertSuperset(dependency.getTargets().contains(callEvent)); + + JoinNode joinNode = UML.createJoinNode(); + assertValid(joinNode); + dependency.getSuppliers().add(joinNode); + assertSuperset(dependency.getTargets().contains(joinNode)); + + Interaction interaction = UML.createInteraction(); + assertValid(interaction); + dependency.getSuppliers().add(interaction); + assertSuperset(dependency.getTargets().contains(interaction)); + + CreateLinkObjectAction createLinkObjectAction = UML + .createCreateLinkObjectAction(); + assertValid(createLinkObjectAction); + dependency.getSuppliers().add(createLinkObjectAction); + assertSuperset( + dependency.getTargets().contains(createLinkObjectAction)); + + OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior(); + assertValid(opaqueBehavior); + dependency.getSuppliers().add(opaqueBehavior); + assertSuperset(dependency.getTargets().contains(opaqueBehavior)); + + LiteralUnlimitedNatural literalUnlimitedNatural = UML + .createLiteralUnlimitedNatural(); + assertValid(literalUnlimitedNatural); + dependency.getSuppliers().add(literalUnlimitedNatural); + assertSuperset( + dependency.getTargets().contains(literalUnlimitedNatural)); + + SendSignalAction sendSignalAction = UML.createSendSignalAction(); + assertValid(sendSignalAction); + dependency.getSuppliers().add(sendSignalAction); + assertSuperset(dependency.getTargets().contains(sendSignalAction)); + + ReadLinkAction readLinkAction = UML.createReadLinkAction(); + assertValid(readLinkAction); + dependency.getSuppliers().add(readLinkAction); + assertSuperset(dependency.getTargets().contains(readLinkAction)); + + Operation operation = UML.createOperation(); + assertValid(operation); + dependency.getSuppliers().add(operation); + assertSuperset(dependency.getTargets().contains(operation)); + + ClearAssociationAction clearAssociationAction = UML + .createClearAssociationAction(); + assertValid(clearAssociationAction); + dependency.getSuppliers().add(clearAssociationAction); + assertSuperset( + dependency.getTargets().contains(clearAssociationAction)); + + Model model = UML.createModel(); + assertValid(model); + dependency.getSuppliers().add(model); + assertSuperset(dependency.getTargets().contains(model)); + + Parameter parameter = UML.createParameter(); + assertValid(parameter); + dependency.getSuppliers().add(parameter); + assertSuperset(dependency.getTargets().contains(parameter)); + + InstanceValue instanceValue = UML.createInstanceValue(); + assertValid(instanceValue); + dependency.getSuppliers().add(instanceValue); + assertSuperset(dependency.getTargets().contains(instanceValue)); + + Trigger trigger = UML.createTrigger(); + assertValid(trigger); + dependency.getSuppliers().add(trigger); + assertSuperset(dependency.getTargets().contains(trigger)); + + InteractionConstraint interactionConstraint = UML + .createInteractionConstraint(); + assertValid(interactionConstraint); + dependency.getSuppliers().add(interactionConstraint); + assertSuperset(dependency.getTargets().contains(interactionConstraint)); + + AssociationClass associationClass = UML.createAssociationClass(); + assertValid(associationClass); + dependency.getSuppliers().add(associationClass); + assertSuperset(dependency.getTargets().contains(associationClass)); + + InteractionUse interactionUse = UML.createInteractionUse(); + assertValid(interactionUse); + dependency.getSuppliers().add(interactionUse); + assertSuperset(dependency.getTargets().contains(interactionUse)); + + ClearStructuralFeatureAction clearStructuralFeatureAction = UML + .createClearStructuralFeatureAction(); + assertValid(clearStructuralFeatureAction); + dependency.getSuppliers().add(clearStructuralFeatureAction); + assertSuperset( + dependency.getTargets().contains(clearStructuralFeatureAction)); + + Interval interval = UML.createInterval(); + assertValid(interval); + dependency.getSuppliers().add(interval); + assertSuperset(dependency.getTargets().contains(interval)); + + StructuredActivityNode structuredActivityNode = UML + .createStructuredActivityNode(); + assertValid(structuredActivityNode); + dependency.getSuppliers().add(structuredActivityNode); + assertSuperset( + dependency.getTargets().contains(structuredActivityNode)); + + LiteralString literalString = UML.createLiteralString(); + assertValid(literalString); + dependency.getSuppliers().add(literalString); + assertSuperset(dependency.getTargets().contains(literalString)); + + ValuePin valuePin = UML.createValuePin(); + assertValid(valuePin); + dependency.getSuppliers().add(valuePin); + assertSuperset(dependency.getTargets().contains(valuePin)); + + InterfaceRealization interfaceRealization = UML + .createInterfaceRealization(); + assertValid(interfaceRealization); + dependency.getSuppliers().add(interfaceRealization); + assertSuperset(dependency.getTargets().contains(interfaceRealization)); + + ForkNode forkNode = UML.createForkNode(); + assertValid(forkNode); + dependency.getSuppliers().add(forkNode); + assertSuperset(dependency.getTargets().contains(forkNode)); + + DecisionNode decisionNode = UML.createDecisionNode(); + assertValid(decisionNode); + dependency.getSuppliers().add(decisionNode); + assertSuperset(dependency.getTargets().contains(decisionNode)); + + Actor actor = UML.createActor(); + assertValid(actor); + dependency.getSuppliers().add(actor); + assertSuperset(dependency.getTargets().contains(actor)); + + TimeConstraint timeConstraint = UML.createTimeConstraint(); + assertValid(timeConstraint); + dependency.getSuppliers().add(timeConstraint); + assertSuperset(dependency.getTargets().contains(timeConstraint)); + + Reception reception = UML.createReception(); + assertValid(reception); + dependency.getSuppliers().add(reception); + assertSuperset(dependency.getTargets().contains(reception)); + + Pseudostate pseudostate = UML.createPseudostate(); + assertValid(pseudostate); + dependency.getSuppliers().add(pseudostate); + assertSuperset(dependency.getTargets().contains(pseudostate)); + + DurationInterval durationInterval = UML.createDurationInterval(); + assertValid(durationInterval); + dependency.getSuppliers().add(durationInterval); + assertSuperset(dependency.getTargets().contains(durationInterval)); + + Deployment deployment = UML.createDeployment(); + assertValid(deployment); + dependency.getSuppliers().add(deployment); + assertSuperset(dependency.getTargets().contains(deployment)); + + ExtensionEnd extensionEnd = UML.createExtensionEnd(); + assertValid(extensionEnd); + dependency.getSuppliers().add(extensionEnd); + assertSuperset(dependency.getTargets().contains(extensionEnd)); + + ConsiderIgnoreFragment considerIgnoreFragment = UML + .createConsiderIgnoreFragment(); + assertValid(considerIgnoreFragment); + dependency.getSuppliers().add(considerIgnoreFragment); + assertSuperset( + dependency.getTargets().contains(considerIgnoreFragment)); + + ConditionalNode conditionalNode = UML.createConditionalNode(); + assertValid(conditionalNode); + dependency.getSuppliers().add(conditionalNode); + assertSuperset(dependency.getTargets().contains(conditionalNode)); + + ReadExtentAction readExtentAction = UML.createReadExtentAction(); + assertValid(readExtentAction); + dependency.getSuppliers().add(readExtentAction); + assertSuperset(dependency.getTargets().contains(readExtentAction)); + + ActionInputPin actionInputPin = UML.createActionInputPin(); + assertValid(actionInputPin); + dependency.getSuppliers().add(actionInputPin); + assertSuperset(dependency.getTargets().contains(actionInputPin)); + + Artifact artifact = UML.createArtifact(); + assertValid(artifact); + dependency.getSuppliers().add(artifact); + assertSuperset(dependency.getTargets().contains(artifact)); + + InformationFlow informationFlow = UML.createInformationFlow(); + assertValid(informationFlow); + dependency.getSuppliers().add(informationFlow); + assertSuperset(dependency.getTargets().contains(informationFlow)); + + ClearVariableAction clearVariableAction = UML + .createClearVariableAction(); + assertValid(clearVariableAction); + dependency.getSuppliers().add(clearVariableAction); + assertSuperset(dependency.getTargets().contains(clearVariableAction)); + + CreateLinkAction createLinkAction = UML.createCreateLinkAction(); + assertValid(createLinkAction); + dependency.getSuppliers().add(createLinkAction); + assertSuperset(dependency.getTargets().contains(createLinkAction)); + + SignalEvent signalEvent = UML.createSignalEvent(); + assertValid(signalEvent); + dependency.getSuppliers().add(signalEvent); + assertSuperset(dependency.getTargets().contains(signalEvent)); + + ConnectionPointReference connectionPointReference = UML + .createConnectionPointReference(); + assertValid(connectionPointReference); + dependency.getSuppliers().add(connectionPointReference); + assertSuperset( + dependency.getTargets().contains(connectionPointReference)); + + ReclassifyObjectAction reclassifyObjectAction = UML + .createReclassifyObjectAction(); + assertValid(reclassifyObjectAction); + dependency.getSuppliers().add(reclassifyObjectAction); + assertSuperset( + dependency.getTargets().contains(reclassifyObjectAction)); + + Usage usage = UML.createUsage(); + assertValid(usage); + dependency.getSuppliers().add(usage); + assertSuperset(dependency.getTargets().contains(usage)); + + DataStoreNode dataStoreNode = UML.createDataStoreNode(); + assertValid(dataStoreNode); + dependency.getSuppliers().add(dataStoreNode); + assertSuperset(dependency.getTargets().contains(dataStoreNode)); + + ExecutionEnvironment executionEnvironment = UML + .createExecutionEnvironment(); + assertValid(executionEnvironment); + dependency.getSuppliers().add(executionEnvironment); + assertSuperset(dependency.getTargets().contains(executionEnvironment)); + + SendObjectAction sendObjectAction = UML.createSendObjectAction(); + assertValid(sendObjectAction); + dependency.getSuppliers().add(sendObjectAction); + assertSuperset(dependency.getTargets().contains(sendObjectAction)); + + ControlFlow controlFlow = UML.createControlFlow(); + assertValid(controlFlow); + dependency.getSuppliers().add(controlFlow); + assertSuperset(dependency.getTargets().contains(controlFlow)); + + DeploymentSpecification deploymentSpecification = UML + .createDeploymentSpecification(); + assertValid(deploymentSpecification); + dependency.getSuppliers().add(deploymentSpecification); + assertSuperset( + dependency.getTargets().contains(deploymentSpecification)); + + PartDecomposition partDecomposition = UML.createPartDecomposition(); + assertValid(partDecomposition); + dependency.getSuppliers().add(partDecomposition); + assertSuperset(dependency.getTargets().contains(partDecomposition)); + + DestroyLinkAction destroyLinkAction = UML.createDestroyLinkAction(); + assertValid(destroyLinkAction); + dependency.getSuppliers().add(destroyLinkAction); + assertSuperset(dependency.getTargets().contains(destroyLinkAction)); + + Realization realization = UML.createRealization(); + assertValid(realization); + dependency.getSuppliers().add(realization); + assertSuperset(dependency.getTargets().contains(realization)); + + ExpansionNode expansionNode = UML.createExpansionNode(); + assertValid(expansionNode); + dependency.getSuppliers().add(expansionNode); + assertSuperset(dependency.getTargets().contains(expansionNode)); + + TestIdentityAction testIdentityAction = UML.createTestIdentityAction(); + assertValid(testIdentityAction); + dependency.getSuppliers().add(testIdentityAction); + assertSuperset(dependency.getTargets().contains(testIdentityAction)); + + Association association = UML.createAssociation(); + assertValid(association); + dependency.getSuppliers().add(association); + assertSuperset(dependency.getTargets().contains(association)); + + TimeInterval timeInterval = UML.createTimeInterval(); + assertValid(timeInterval); + dependency.getSuppliers().add(timeInterval); + assertSuperset(dependency.getTargets().contains(timeInterval)); + + DataType dataType = UML.createDataType(); + assertValid(dataType); + dependency.getSuppliers().add(dataType); + assertSuperset(dependency.getTargets().contains(dataType)); + + OutputPin outputPin = UML.createOutputPin(); + assertValid(outputPin); + dependency.getSuppliers().add(outputPin); + assertSuperset(dependency.getTargets().contains(outputPin)); + + Substitution substitution = UML.createSubstitution(); + assertValid(substitution); + dependency.getSuppliers().add(substitution); + assertSuperset(dependency.getTargets().contains(substitution)); + + Include include = UML.createInclude(); + assertValid(include); + dependency.getSuppliers().add(include); + assertSuperset(dependency.getTargets().contains(include)); + + Extend extend = UML.createExtend(); + assertValid(extend); + dependency.getSuppliers().add(extend); + assertSuperset(dependency.getTargets().contains(extend)); + + BroadcastSignalAction broadcastSignalAction = UML + .createBroadcastSignalAction(); + assertValid(broadcastSignalAction); + dependency.getSuppliers().add(broadcastSignalAction); + assertSuperset(dependency.getTargets().contains(broadcastSignalAction)); + + LiteralBoolean literalBoolean = UML.createLiteralBoolean(); + assertValid(literalBoolean); + dependency.getSuppliers().add(literalBoolean); + assertSuperset(dependency.getTargets().contains(literalBoolean)); + + FinalState finalState = UML.createFinalState(); + assertValid(finalState); + dependency.getSuppliers().add(finalState); + assertSuperset(dependency.getTargets().contains(finalState)); + + RaiseExceptionAction raiseExceptionAction = UML + .createRaiseExceptionAction(); + assertValid(raiseExceptionAction); + dependency.getSuppliers().add(raiseExceptionAction); + assertSuperset(dependency.getTargets().contains(raiseExceptionAction)); + + DurationConstraint durationConstraint = UML.createDurationConstraint(); + assertValid(durationConstraint); + dependency.getSuppliers().add(durationConstraint); + assertSuperset(dependency.getTargets().contains(durationConstraint)); + + ActivityFinalNode activityFinalNode = UML.createActivityFinalNode(); + assertValid(activityFinalNode); + dependency.getSuppliers().add(activityFinalNode); + assertSuperset(dependency.getTargets().contains(activityFinalNode)); + + LiteralNull literalNull = UML.createLiteralNull(); + assertValid(literalNull); + dependency.getSuppliers().add(literalNull); + assertSuperset(dependency.getTargets().contains(literalNull)); + + CallOperationAction callOperationAction = UML + .createCallOperationAction(); + assertValid(callOperationAction); + dependency.getSuppliers().add(callOperationAction); + assertSuperset(dependency.getTargets().contains(callOperationAction)); + + ProtocolStateMachine protocolStateMachine = UML + .createProtocolStateMachine(); + assertValid(protocolStateMachine); + dependency.getSuppliers().add(protocolStateMachine); + assertSuperset(dependency.getTargets().contains(protocolStateMachine)); + + LoopNode loopNode = UML.createLoopNode(); + assertValid(loopNode); + dependency.getSuppliers().add(loopNode); + assertSuperset(dependency.getTargets().contains(loopNode)); + + ParameterSet parameterSet = UML.createParameterSet(); + assertValid(parameterSet); + dependency.getSuppliers().add(parameterSet); + assertSuperset(dependency.getTargets().contains(parameterSet)); + + ValueSpecificationAction valueSpecificationAction = UML + .createValueSpecificationAction(); + assertValid(valueSpecificationAction); + dependency.getSuppliers().add(valueSpecificationAction); + assertSuperset( + dependency.getTargets().contains(valueSpecificationAction)); + + Node node = UML.createNode(); + assertValid(node); + dependency.getSuppliers().add(node); + assertSuperset(dependency.getTargets().contains(node)); + + SequenceNode sequenceNode = UML.createSequenceNode(); + assertValid(sequenceNode); + dependency.getSuppliers().add(sequenceNode); + assertSuperset(dependency.getTargets().contains(sequenceNode)); + + Constraint constraint = UML.createConstraint(); + assertValid(constraint); + dependency.getSuppliers().add(constraint); + assertSuperset(dependency.getTargets().contains(constraint)); + + DestroyObjectAction destroyObjectAction = UML + .createDestroyObjectAction(); + assertValid(destroyObjectAction); + dependency.getSuppliers().add(destroyObjectAction); + assertSuperset(dependency.getTargets().contains(destroyObjectAction)); + + StateMachine stateMachine = UML.createStateMachine(); + assertValid(stateMachine); + dependency.getSuppliers().add(stateMachine); + assertSuperset(dependency.getTargets().contains(stateMachine)); + + EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral); + dependency.getSuppliers().add(enumerationLiteral); + assertSuperset(dependency.getTargets().contains(enumerationLiteral)); + + ActionExecutionSpecification actionExecutionSpecification = UML + .createActionExecutionSpecification(); + assertValid(actionExecutionSpecification); + dependency.getSuppliers().add(actionExecutionSpecification); + assertSuperset( + dependency.getTargets().contains(actionExecutionSpecification)); + + FunctionBehavior functionBehavior = UML.createFunctionBehavior(); + assertValid(functionBehavior); + dependency.getSuppliers().add(functionBehavior); + assertSuperset(dependency.getTargets().contains(functionBehavior)); + + Interface interface_ = UML.createInterface(); + assertValid(interface_); + dependency.getSuppliers().add(interface_); + assertSuperset(dependency.getTargets().contains(interface_)); + + InstanceSpecification instanceSpecification = UML + .createInstanceSpecification(); + assertValid(instanceSpecification); + dependency.getSuppliers().add(instanceSpecification); + assertSuperset(dependency.getTargets().contains(instanceSpecification)); + + StartClassifierBehaviorAction startClassifierBehaviorAction = UML + .createStartClassifierBehaviorAction(); + assertValid(startClassifierBehaviorAction); + dependency.getSuppliers().add(startClassifierBehaviorAction); + assertSuperset( + dependency.getTargets().contains(startClassifierBehaviorAction)); + + Port port = UML.createPort(); + assertValid(port); + dependency.getSuppliers().add(port); + assertSuperset(dependency.getTargets().contains(port)); + + RemoveVariableValueAction removeVariableValueAction = UML + .createRemoveVariableValueAction(); + assertValid(removeVariableValueAction); + dependency.getSuppliers().add(removeVariableValueAction); + assertSuperset( + dependency.getTargets().contains(removeVariableValueAction)); + + InformationItem informationItem = UML.createInformationItem(); + assertValid(informationItem); + dependency.getSuppliers().add(informationItem); + assertSuperset(dependency.getTargets().contains(informationItem)); + + LiteralReal literalReal = UML.createLiteralReal(); + assertValid(literalReal); + dependency.getSuppliers().add(literalReal); + assertSuperset(dependency.getTargets().contains(literalReal)); + + RedefinableTemplateSignature redefinableTemplateSignature = UML + .createRedefinableTemplateSignature(); + assertValid(redefinableTemplateSignature); + dependency.getSuppliers().add(redefinableTemplateSignature); + assertSuperset( + dependency.getTargets().contains(redefinableTemplateSignature)); + + ExecutionOccurrenceSpecification executionOccurrenceSpecification = UML + .createExecutionOccurrenceSpecification(); + assertValid(executionOccurrenceSpecification); + dependency.getSuppliers().add(executionOccurrenceSpecification); + assertSuperset( + dependency.getTargets().contains(executionOccurrenceSpecification)); + + Duration duration = UML.createDuration(); + assertValid(duration); + dependency.getSuppliers().add(duration); + assertSuperset(dependency.getTargets().contains(duration)); + + org.eclipse.uml2.uml.Package package_ = UML.createPackage(); + assertValid(package_); + dependency.getSuppliers().add(package_); + assertSuperset(dependency.getTargets().contains(package_)); + + Variable variable = UML.createVariable(); + assertValid(variable); + dependency.getSuppliers().add(variable); + assertSuperset(dependency.getTargets().contains(variable)); + + DestructionOccurrenceSpecification destructionOccurrenceSpecification = UML + .createDestructionOccurrenceSpecification(); + assertValid(destructionOccurrenceSpecification); + dependency.getSuppliers().add(destructionOccurrenceSpecification); + assertSuperset(dependency.getTargets() + .contains(destructionOccurrenceSpecification)); + + Lifeline lifeline = UML.createLifeline(); + assertValid(lifeline); + dependency.getSuppliers().add(lifeline); + assertSuperset(dependency.getTargets().contains(lifeline)); + + TimeObservation timeObservation = UML.createTimeObservation(); + assertValid(timeObservation); + dependency.getSuppliers().add(timeObservation); + assertSuperset(dependency.getTargets().contains(timeObservation)); + + ReplyAction replyAction = UML.createReplyAction(); + assertValid(replyAction); + dependency.getSuppliers().add(replyAction); + assertSuperset(dependency.getTargets().contains(replyAction)); + + Gate gate = UML.createGate(); + assertValid(gate); + dependency.getSuppliers().add(gate); + assertSuperset(dependency.getTargets().contains(gate)); + + Property property = UML.createProperty(); + assertValid(property); + dependency.getSuppliers().add(property); + assertSuperset(dependency.getTargets().contains(property)); + + TimeExpression timeExpression = UML.createTimeExpression(); + assertValid(timeExpression); + dependency.getSuppliers().add(timeExpression); + assertSuperset(dependency.getTargets().contains(timeExpression)); + + Device device = UML.createDevice(); + assertValid(device); + dependency.getSuppliers().add(device); + assertSuperset(dependency.getTargets().contains(device)); + + FlowFinalNode flowFinalNode = UML.createFlowFinalNode(); + assertValid(flowFinalNode); + dependency.getSuppliers().add(flowFinalNode); + assertSuperset(dependency.getTargets().contains(flowFinalNode)); + + ExpansionRegion expansionRegion = UML.createExpansionRegion(); + assertValid(expansionRegion); + dependency.getSuppliers().add(expansionRegion); + assertSuperset(dependency.getTargets().contains(expansionRegion)); + + Abstraction abstraction = UML.createAbstraction(); + assertValid(abstraction); + dependency.getSuppliers().add(abstraction); + assertSuperset(dependency.getTargets().contains(abstraction)); + + StartObjectBehaviorAction startObjectBehaviorAction = UML + .createStartObjectBehaviorAction(); + assertValid(startObjectBehaviorAction); + dependency.getSuppliers().add(startObjectBehaviorAction); + assertSuperset( + dependency.getTargets().contains(startObjectBehaviorAction)); + + Enumeration enumeration = UML.createEnumeration(); + assertValid(enumeration); + dependency.getSuppliers().add(enumeration); + assertSuperset(dependency.getTargets().contains(enumeration)); + + PrimitiveType primitiveType = UML.createPrimitiveType(); + assertValid(primitiveType); + dependency.getSuppliers().add(primitiveType); + assertSuperset(dependency.getTargets().contains(primitiveType)); + + Profile profile = UML.createProfile(); + assertValid(profile); + dependency.getSuppliers().add(profile); + assertSuperset(dependency.getTargets().contains(profile)); + + Message message = UML.createMessage(); + assertValid(message); + dependency.getSuppliers().add(message); + assertSuperset(dependency.getTargets().contains(message)); + + GeneralizationSet generalizationSet = UML.createGeneralizationSet(); + assertValid(generalizationSet); + dependency.getSuppliers().add(generalizationSet); + assertSuperset(dependency.getTargets().contains(generalizationSet)); + + Continuation continuation = UML.createContinuation(); + assertValid(continuation); + dependency.getSuppliers().add(continuation); + assertSuperset(dependency.getTargets().contains(continuation)); + + Signal signal = UML.createSignal(); + assertValid(signal); + dependency.getSuppliers().add(signal); + assertSuperset(dependency.getTargets().contains(signal)); + + CallBehaviorAction callBehaviorAction = UML.createCallBehaviorAction(); + assertValid(callBehaviorAction); + dependency.getSuppliers().add(callBehaviorAction); + assertSuperset(dependency.getTargets().contains(callBehaviorAction)); + + ObjectFlow objectFlow = UML.createObjectFlow(); + assertValid(objectFlow); + dependency.getSuppliers().add(objectFlow); + assertSuperset(dependency.getTargets().contains(objectFlow)); + + StateInvariant stateInvariant = UML.createStateInvariant(); + assertValid(stateInvariant); + dependency.getSuppliers().add(stateInvariant); + assertSuperset(dependency.getTargets().contains(stateInvariant)); + + ReadIsClassifiedObjectAction readIsClassifiedObjectAction = UML + .createReadIsClassifiedObjectAction(); + assertValid(readIsClassifiedObjectAction); + dependency.getSuppliers().add(readIsClassifiedObjectAction); + assertSuperset( + dependency.getTargets().contains(readIsClassifiedObjectAction)); + + ActivityParameterNode activityParameterNode = UML + .createActivityParameterNode(); + assertValid(activityParameterNode); + dependency.getSuppliers().add(activityParameterNode); + assertSuperset(dependency.getTargets().contains(activityParameterNode)); + + AddStructuralFeatureValueAction addStructuralFeatureValueAction = UML + .createAddStructuralFeatureValueAction(); + assertValid(addStructuralFeatureValueAction); + dependency.getSuppliers().add(addStructuralFeatureValueAction); + assertSuperset( + dependency.getTargets().contains(addStructuralFeatureValueAction)); + + ReadVariableAction readVariableAction = UML.createReadVariableAction(); + assertValid(readVariableAction); + dependency.getSuppliers().add(readVariableAction); + assertSuperset(dependency.getTargets().contains(readVariableAction)); + + InterruptibleActivityRegion interruptibleActivityRegion = UML + .createInterruptibleActivityRegion(); + assertValid(interruptibleActivityRegion); + dependency.getSuppliers().add(interruptibleActivityRegion); + assertSuperset( + dependency.getTargets().contains(interruptibleActivityRegion)); + + RemoveStructuralFeatureValueAction removeStructuralFeatureValueAction = UML + .createRemoveStructuralFeatureValueAction(); + assertValid(removeStructuralFeatureValueAction); + dependency.getSuppliers().add(removeStructuralFeatureValueAction); + assertSuperset(dependency.getTargets() + .contains(removeStructuralFeatureValueAction)); + + OpaqueExpression opaqueExpression = UML.createOpaqueExpression(); + assertValid(opaqueExpression); + dependency.getSuppliers().add(opaqueExpression); + assertSuperset(dependency.getTargets().contains(opaqueExpression)); + + TimeEvent timeEvent = UML.createTimeEvent(); + assertValid(timeEvent); + dependency.getSuppliers().add(timeEvent); + assertSuperset(dependency.getTargets().contains(timeEvent)); + + GeneralOrdering generalOrdering = UML.createGeneralOrdering(); + assertValid(generalOrdering); + dependency.getSuppliers().add(generalOrdering); + assertSuperset(dependency.getTargets().contains(generalOrdering)); + + Region region = UML.createRegion(); + assertValid(region); + dependency.getSuppliers().add(region); + assertSuperset(dependency.getTargets().contains(region)); + + Transition transition = UML.createTransition(); + assertValid(transition); + dependency.getSuppliers().add(transition); + assertSuperset(dependency.getTargets().contains(transition)); + + AnyReceiveEvent anyReceiveEvent = UML.createAnyReceiveEvent(); + assertValid(anyReceiveEvent); + dependency.getSuppliers().add(anyReceiveEvent); + assertSuperset(dependency.getTargets().contains(anyReceiveEvent)); + + MessageOccurrenceSpecification messageOccurrenceSpecification = UML + .createMessageOccurrenceSpecification(); + assertValid(messageOccurrenceSpecification); + dependency.getSuppliers().add(messageOccurrenceSpecification); + assertSuperset( + dependency.getTargets().contains(messageOccurrenceSpecification)); + + LiteralInteger literalInteger = UML.createLiteralInteger(); + assertValid(literalInteger); + dependency.getSuppliers().add(literalInteger); + assertSuperset(dependency.getTargets().contains(literalInteger)); + + ReduceAction reduceAction = UML.createReduceAction(); + assertValid(reduceAction); + dependency.getSuppliers().add(reduceAction); + assertSuperset(dependency.getTargets().contains(reduceAction)); + + AcceptEventAction acceptEventAction = UML.createAcceptEventAction(); + assertValid(acceptEventAction); + dependency.getSuppliers().add(acceptEventAction); + assertSuperset(dependency.getTargets().contains(acceptEventAction)); + + InitialNode initialNode = UML.createInitialNode(); + assertValid(initialNode); + dependency.getSuppliers().add(initialNode); + assertSuperset(dependency.getTargets().contains(initialNode)); + + CentralBufferNode centralBufferNode = UML.createCentralBufferNode(); + assertValid(centralBufferNode); + dependency.getSuppliers().add(centralBufferNode); + assertSuperset(dependency.getTargets().contains(centralBufferNode)); + + CombinedFragment combinedFragment = UML.createCombinedFragment(); + assertValid(combinedFragment); + dependency.getSuppliers().add(combinedFragment); + assertSuperset(dependency.getTargets().contains(combinedFragment)); + + IntervalConstraint intervalConstraint = UML.createIntervalConstraint(); + assertValid(intervalConstraint); + dependency.getSuppliers().add(intervalConstraint); + assertSuperset(dependency.getTargets().contains(intervalConstraint)); + + Extension extension = UML.createExtension(); + assertValid(extension); + dependency.getSuppliers().add(extension); + assertSuperset(dependency.getTargets().contains(extension)); + + OccurrenceSpecification occurrenceSpecification = UML + .createOccurrenceSpecification(); + assertValid(occurrenceSpecification); + dependency.getSuppliers().add(occurrenceSpecification); + assertSuperset( + dependency.getTargets().contains(occurrenceSpecification)); + + ExtensionPoint extensionPoint = UML.createExtensionPoint(); + assertValid(extensionPoint); + dependency.getSuppliers().add(extensionPoint); + assertSuperset(dependency.getTargets().contains(extensionPoint)); + + Dependency dependency2 = UML.createDependency(); + assertValid(dependency2); + dependency.getSuppliers().add(dependency2); + assertSuperset(dependency.getTargets().contains(dependency2)); + + Connector connector = UML.createConnector(); + assertValid(connector); + dependency.getSuppliers().add(connector); + assertSuperset(dependency.getTargets().contains(connector)); + + Expression expression = UML.createExpression(); + assertValid(expression); + dependency.getSuppliers().add(expression); + assertSuperset(dependency.getTargets().contains(expression)); + + ComponentRealization componentRealization = UML + .createComponentRealization(); + assertValid(componentRealization); + dependency.getSuppliers().add(componentRealization); + assertSuperset(dependency.getTargets().contains(componentRealization)); + + org.eclipse.uml2.uml.Class class_ = UML.createClass(); + assertValid(class_); + dependency.getSuppliers().add(class_); + assertSuperset(dependency.getTargets().contains(class_)); + + State state = UML.createState(); + assertValid(state); + dependency.getSuppliers().add(state); + assertSuperset(dependency.getTargets().contains(state)); + + ProtocolTransition protocolTransition = UML.createProtocolTransition(); + assertValid(protocolTransition); + dependency.getSuppliers().add(protocolTransition); + assertSuperset(dependency.getTargets().contains(protocolTransition)); + + BehaviorExecutionSpecification behaviorExecutionSpecification = UML + .createBehaviorExecutionSpecification(); + assertValid(behaviorExecutionSpecification); + dependency.getSuppliers().add(behaviorExecutionSpecification); + assertSuperset( + dependency.getTargets().contains(behaviorExecutionSpecification)); + + CollaborationUse collaborationUse = UML.createCollaborationUse(); + assertValid(collaborationUse); + dependency.getSuppliers().add(collaborationUse); + assertSuperset(dependency.getTargets().contains(collaborationUse)); + + InteractionOperand interactionOperand = UML.createInteractionOperand(); + assertValid(interactionOperand); + dependency.getSuppliers().add(interactionOperand); + assertSuperset(dependency.getTargets().contains(interactionOperand)); + + AcceptCallAction acceptCallAction = UML.createAcceptCallAction(); + assertValid(acceptCallAction); + dependency.getSuppliers().add(acceptCallAction); + assertSuperset(dependency.getTargets().contains(acceptCallAction)); + + AddVariableValueAction addVariableValueAction = UML + .createAddVariableValueAction(); + assertValid(addVariableValueAction); + dependency.getSuppliers().add(addVariableValueAction); + assertSuperset( + dependency.getTargets().contains(addVariableValueAction)); + + ReadLinkObjectEndAction readLinkObjectEndAction = UML + .createReadLinkObjectEndAction(); + assertValid(readLinkObjectEndAction); + dependency.getSuppliers().add(readLinkObjectEndAction); + assertSuperset( + dependency.getTargets().contains(readLinkObjectEndAction)); + + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + dependency.getSuppliers().add(useCase); + assertSuperset(dependency.getTargets().contains(useCase)); + + UnmarshallAction unmarshallAction = UML.createUnmarshallAction(); + assertValid(unmarshallAction); + dependency.getSuppliers().add(unmarshallAction); + assertSuperset(dependency.getTargets().contains(unmarshallAction)); + + OpaqueAction opaqueAction = UML.createOpaqueAction(); + assertValid(opaqueAction); + dependency.getSuppliers().add(opaqueAction); + assertSuperset(dependency.getTargets().contains(opaqueAction)); + + StringExpression stringExpression = UML.createStringExpression(); + assertValid(stringExpression); + dependency.getSuppliers().add(stringExpression); + assertSuperset(dependency.getTargets().contains(stringExpression)); + + MergeNode mergeNode = UML.createMergeNode(); + assertValid(mergeNode); + dependency.getSuppliers().add(mergeNode); + assertSuperset(dependency.getTargets().contains(mergeNode)); + + ChangeEvent changeEvent = UML.createChangeEvent(); + assertValid(changeEvent); + dependency.getSuppliers().add(changeEvent); + assertSuperset(dependency.getTargets().contains(changeEvent)); + + CreateObjectAction createObjectAction = UML.createCreateObjectAction(); + assertValid(createObjectAction); + dependency.getSuppliers().add(createObjectAction); + assertSuperset(dependency.getTargets().contains(createObjectAction)); + + Stereotype stereotype = UML.createStereotype(); + assertValid(stereotype); + dependency.getSuppliers().add(stereotype); + assertSuperset(dependency.getTargets().contains(stereotype)); + + ReadStructuralFeatureAction readStructuralFeatureAction = UML + .createReadStructuralFeatureAction(); + assertValid(readStructuralFeatureAction); + dependency.getSuppliers().add(readStructuralFeatureAction); + assertSuperset( + dependency.getTargets().contains(readStructuralFeatureAction)); + + Collaboration collaboration = UML.createCollaboration(); + assertValid(collaboration); + dependency.getSuppliers().add(collaboration); + assertSuperset(dependency.getTargets().contains(collaboration)); + } + +} |