diff options
Diffstat (limited to 'cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/UseCaseTest.java')
| -rwxr-xr-x | cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/UseCaseTest.java | 710 |
1 files changed, 710 insertions, 0 deletions
diff --git a/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/UseCaseTest.java b/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/UseCaseTest.java new file mode 100755 index 00000000..d2a1cffd --- /dev/null +++ b/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/UseCaseTest.java @@ -0,0 +1,710 @@ +/* + * 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.Activity; +import org.eclipse.uml2.uml.Actor; +import org.eclipse.uml2.uml.Artifact; +import org.eclipse.uml2.uml.Association; +import org.eclipse.uml2.uml.AssociationClass; +import org.eclipse.uml2.uml.Classifier; +import org.eclipse.uml2.uml.ClassifierTemplateParameter; +import org.eclipse.uml2.uml.Collaboration; +import org.eclipse.uml2.uml.CollaborationUse; +import org.eclipse.uml2.uml.Comment; +import org.eclipse.uml2.uml.CommunicationPath; +import org.eclipse.uml2.uml.Component; +import org.eclipse.uml2.uml.Constraint; +import org.eclipse.uml2.uml.DataType; +import org.eclipse.uml2.uml.Dependency; +import org.eclipse.uml2.uml.DeploymentSpecification; +import org.eclipse.uml2.uml.Device; +import org.eclipse.uml2.uml.DurationConstraint; +import org.eclipse.uml2.uml.Element; +import org.eclipse.uml2.uml.ElementImport; +import org.eclipse.uml2.uml.Enumeration; +import org.eclipse.uml2.uml.ExecutionEnvironment; +import org.eclipse.uml2.uml.Extend; +import org.eclipse.uml2.uml.Extension; +import org.eclipse.uml2.uml.ExtensionPoint; +import org.eclipse.uml2.uml.Feature; +import org.eclipse.uml2.uml.FunctionBehavior; +import org.eclipse.uml2.uml.Generalization; +import org.eclipse.uml2.uml.GeneralizationSet; +import org.eclipse.uml2.uml.Include; +import org.eclipse.uml2.uml.InformationItem; +import org.eclipse.uml2.uml.Interaction; +import org.eclipse.uml2.uml.InteractionConstraint; +import org.eclipse.uml2.uml.Interface; +import org.eclipse.uml2.uml.InterfaceRealization; +import org.eclipse.uml2.uml.IntervalConstraint; +import org.eclipse.uml2.uml.NamedElement; +import org.eclipse.uml2.uml.Node; +import org.eclipse.uml2.uml.OpaqueBehavior; +import org.eclipse.uml2.uml.PackageImport; +import org.eclipse.uml2.uml.PackageableElement; +import org.eclipse.uml2.uml.PrimitiveType; +import org.eclipse.uml2.uml.Property; +import org.eclipse.uml2.uml.ProtocolStateMachine; +import org.eclipse.uml2.uml.RedefinableElement; +import org.eclipse.uml2.uml.RedefinableTemplateSignature; +import org.eclipse.uml2.uml.Signal; +import org.eclipse.uml2.uml.StateMachine; +import org.eclipse.uml2.uml.Stereotype; +import org.eclipse.uml2.uml.StringExpression; +import org.eclipse.uml2.uml.Substitution; +import org.eclipse.uml2.uml.TemplateBinding; +import org.eclipse.uml2.uml.TimeConstraint; +import org.eclipse.uml2.uml.UseCase; + +/** + * @author Eike Stepper + */ +public class UseCaseTest + extends _Abstract_Compliance_Test_ { + + public void testEAnnotations() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + EAnnotation eAnnotation = ECORE.createEAnnotation(); + assertValid(eAnnotation); + useCase.getEAnnotations().add(eAnnotation); + } + + public void testOwnedComment() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + Comment comment = UML.createComment(); + assertValid(comment); + useCase.getOwnedComments().add(comment); + assertSuperset(useCase.getOwnedElements().contains(comment)); + } + + public void testOwnedElement() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + EList<Element> elements = useCase.getOwnedElements(); + EList<Element> elements2 = useCase.getOwnedElements(); + assertSame(elements, elements2); + } + + public void testClientDependency() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + EList<Dependency> dependencys = useCase.getClientDependencies(); + EList<Dependency> dependencys2 = useCase.getClientDependencies(); + assertSame(dependencys, dependencys2); + } + + public void testNameExpression() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + StringExpression stringExpression = UML.createStringExpression(); + assertValid(stringExpression); + useCase.setNameExpression(stringExpression); + assertSuperset(useCase.getOwnedElements().contains(stringExpression)); + } + + public void testOwnedRule() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + IntervalConstraint intervalConstraint = UML.createIntervalConstraint(); + assertValid(intervalConstraint); + useCase.getOwnedRules().add(intervalConstraint); + assertSuperset(useCase.getOwnedMembers().contains(intervalConstraint)); + + TimeConstraint timeConstraint = UML.createTimeConstraint(); + assertValid(timeConstraint); + useCase.getOwnedRules().add(timeConstraint); + assertSuperset(useCase.getOwnedMembers().contains(timeConstraint)); + + InteractionConstraint interactionConstraint = UML + .createInteractionConstraint(); + assertValid(interactionConstraint); + useCase.getOwnedRules().add(interactionConstraint); + assertSuperset( + useCase.getOwnedMembers().contains(interactionConstraint)); + + Constraint constraint = UML.createConstraint(); + assertValid(constraint); + useCase.getOwnedRules().add(constraint); + assertSuperset(useCase.getOwnedMembers().contains(constraint)); + + DurationConstraint durationConstraint = UML.createDurationConstraint(); + assertValid(durationConstraint); + useCase.getOwnedRules().add(durationConstraint); + assertSuperset(useCase.getOwnedMembers().contains(durationConstraint)); + } + + public void testElementImport() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + ElementImport elementImport = UML.createElementImport(); + assertValid(elementImport); + useCase.getElementImports().add(elementImport); + assertSuperset(useCase.getOwnedElements().contains(elementImport)); + } + + public void testPackageImport() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + PackageImport packageImport = UML.createPackageImport(); + assertValid(packageImport); + useCase.getPackageImports().add(packageImport); + assertSuperset(useCase.getOwnedElements().contains(packageImport)); + } + + public void testOwnedMember() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + EList<NamedElement> namedElements = useCase.getOwnedMembers(); + EList<NamedElement> namedElements2 = useCase.getOwnedMembers(); + assertSame(namedElements, namedElements2); + } + + public void testImportedMember() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + EList<PackageableElement> packageableElements = useCase + .getImportedMembers(); + EList<PackageableElement> packageableElements2 = useCase + .getImportedMembers(); + assertSame(packageableElements, packageableElements2); + } + + public void testMember() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + EList<NamedElement> namedElements = useCase.getMembers(); + EList<NamedElement> namedElements2 = useCase.getMembers(); + assertSame(namedElements, namedElements2); + } + + public void testRedefinedElement() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + EList<RedefinableElement> redefinableElements = useCase + .getRedefinedElements(); + EList<RedefinableElement> redefinableElements2 = useCase + .getRedefinedElements(); + assertSame(redefinableElements, redefinableElements2); + } + + public void testRedefinitionContext() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + EList<Classifier> classifiers = useCase.getRedefinitionContexts(); + EList<Classifier> classifiers2 = useCase.getRedefinitionContexts(); + assertSame(classifiers, classifiers2); + } + + public void testOwningTemplateParameter() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + ClassifierTemplateParameter classifierTemplateParameter = UML + .createClassifierTemplateParameter(); + assertValid(classifierTemplateParameter); + useCase.setOwningTemplateParameter(classifierTemplateParameter); + assertSuperset(useCase.getOwner() == classifierTemplateParameter); + assertSuperset( + useCase.getTemplateParameter() == classifierTemplateParameter); + } + + public void testTemplateParameter() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + ClassifierTemplateParameter classifierTemplateParameter = UML + .createClassifierTemplateParameter(); + assertValid(classifierTemplateParameter); + useCase.setTemplateParameter(classifierTemplateParameter); + } + + public void testTemplateBinding() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + TemplateBinding templateBinding = UML.createTemplateBinding(); + assertValid(templateBinding); + useCase.getTemplateBindings().add(templateBinding); + assertSuperset(useCase.getOwnedElements().contains(templateBinding)); + } + + public void testOwnedTemplateSignature() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + RedefinableTemplateSignature redefinableTemplateSignature = UML + .createRedefinableTemplateSignature(); + assertValid(redefinableTemplateSignature); + useCase.setOwnedTemplateSignature(redefinableTemplateSignature); + assertSuperset( + useCase.getOwnedElements().contains(redefinableTemplateSignature)); + } + + public void testFeature() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + EList<Feature> features = useCase.getFeatures(); + EList<Feature> features2 = useCase.getFeatures(); + assertSame(features, features2); + } + + public void testAttribute() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + EList<Property> propertys = useCase.getAttributes(); + EList<Property> propertys2 = useCase.getAttributes(); + assertSame(propertys, propertys2); + } + + public void testCollaborationUse() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + CollaborationUse collaborationUse = UML.createCollaborationUse(); + assertValid(collaborationUse); + useCase.getCollaborationUses().add(collaborationUse); + assertSuperset(useCase.getOwnedElements().contains(collaborationUse)); + } + + public void testGeneral() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + EList<Classifier> classifiers = useCase.getGenerals(); + EList<Classifier> classifiers2 = useCase.getGenerals(); + assertSame(classifiers, classifiers2); + } + + public void testGeneralization() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + Generalization generalization = UML.createGeneralization(); + assertValid(generalization); + useCase.getGeneralizations().add(generalization); + assertSuperset(useCase.getOwnedElements().contains(generalization)); + } + + public void testPowertypeExtent() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + GeneralizationSet generalizationSet = UML.createGeneralizationSet(); + assertValid(generalizationSet); + useCase.getPowertypeExtents().add(generalizationSet); + } + + public void testInheritedMember() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + EList<NamedElement> namedElements = useCase.getInheritedMembers(); + EList<NamedElement> namedElements2 = useCase.getInheritedMembers(); + assertSame(namedElements, namedElements2); + } + + public void testOwnedUseCase() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + UseCase useCase2 = UML.createUseCase(); + assertValid(useCase2); + useCase.getOwnedUseCases().add(useCase2); + assertSuperset(useCase.getOwnedMembers().contains(useCase2)); + } + + public void testUseCase() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + UseCase useCase2 = UML.createUseCase(); + assertValid(useCase2); + useCase.getUseCases().add(useCase2); + } + + public void testRedefinedClassifier() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + FunctionBehavior functionBehavior = UML.createFunctionBehavior(); + assertValid(functionBehavior); + useCase.getRedefinedClassifiers().add(functionBehavior); + assertSuperset( + useCase.getRedefinedElements().contains(functionBehavior)); + + Activity activity = UML.createActivity(); + assertValid(activity); + useCase.getRedefinedClassifiers().add(activity); + assertSuperset(useCase.getRedefinedElements().contains(activity)); + + Interface interface_ = UML.createInterface(); + assertValid(interface_); + useCase.getRedefinedClassifiers().add(interface_); + assertSuperset(useCase.getRedefinedElements().contains(interface_)); + + InformationItem informationItem = UML.createInformationItem(); + assertValid(informationItem); + useCase.getRedefinedClassifiers().add(informationItem); + assertSuperset( + useCase.getRedefinedElements().contains(informationItem)); + + CommunicationPath communicationPath = UML.createCommunicationPath(); + assertValid(communicationPath); + useCase.getRedefinedClassifiers().add(communicationPath); + assertSuperset( + useCase.getRedefinedElements().contains(communicationPath)); + + ExecutionEnvironment executionEnvironment = UML + .createExecutionEnvironment(); + assertValid(executionEnvironment); + useCase.getRedefinedClassifiers().add(executionEnvironment); + assertSuperset( + useCase.getRedefinedElements().contains(executionEnvironment)); + + Component component = UML.createComponent(); + assertValid(component); + useCase.getRedefinedClassifiers().add(component); + assertSuperset(useCase.getRedefinedElements().contains(component)); + + Interaction interaction = UML.createInteraction(); + assertValid(interaction); + useCase.getRedefinedClassifiers().add(interaction); + assertSuperset(useCase.getRedefinedElements().contains(interaction)); + + DeploymentSpecification deploymentSpecification = UML + .createDeploymentSpecification(); + assertValid(deploymentSpecification); + useCase.getRedefinedClassifiers().add(deploymentSpecification); + assertSuperset( + useCase.getRedefinedElements().contains(deploymentSpecification)); + + OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior(); + assertValid(opaqueBehavior); + useCase.getRedefinedClassifiers().add(opaqueBehavior); + assertSuperset(useCase.getRedefinedElements().contains(opaqueBehavior)); + + Association association = UML.createAssociation(); + assertValid(association); + useCase.getRedefinedClassifiers().add(association); + assertSuperset(useCase.getRedefinedElements().contains(association)); + + DataType dataType = UML.createDataType(); + assertValid(dataType); + useCase.getRedefinedClassifiers().add(dataType); + assertSuperset(useCase.getRedefinedElements().contains(dataType)); + + Device device = UML.createDevice(); + assertValid(device); + useCase.getRedefinedClassifiers().add(device); + assertSuperset(useCase.getRedefinedElements().contains(device)); + + Extension extension = UML.createExtension(); + assertValid(extension); + useCase.getRedefinedClassifiers().add(extension); + assertSuperset(useCase.getRedefinedElements().contains(extension)); + + AssociationClass associationClass = UML.createAssociationClass(); + assertValid(associationClass); + useCase.getRedefinedClassifiers().add(associationClass); + assertSuperset( + useCase.getRedefinedElements().contains(associationClass)); + + org.eclipse.uml2.uml.Class class_ = UML.createClass(); + assertValid(class_); + useCase.getRedefinedClassifiers().add(class_); + assertSuperset(useCase.getRedefinedElements().contains(class_)); + + Enumeration enumeration = UML.createEnumeration(); + assertValid(enumeration); + useCase.getRedefinedClassifiers().add(enumeration); + assertSuperset(useCase.getRedefinedElements().contains(enumeration)); + + PrimitiveType primitiveType = UML.createPrimitiveType(); + assertValid(primitiveType); + useCase.getRedefinedClassifiers().add(primitiveType); + assertSuperset(useCase.getRedefinedElements().contains(primitiveType)); + + Actor actor = UML.createActor(); + assertValid(actor); + useCase.getRedefinedClassifiers().add(actor); + assertSuperset(useCase.getRedefinedElements().contains(actor)); + + ProtocolStateMachine protocolStateMachine = UML + .createProtocolStateMachine(); + assertValid(protocolStateMachine); + useCase.getRedefinedClassifiers().add(protocolStateMachine); + assertSuperset( + useCase.getRedefinedElements().contains(protocolStateMachine)); + + UseCase useCase2 = UML.createUseCase(); + assertValid(useCase2); + useCase.getRedefinedClassifiers().add(useCase2); + assertSuperset(useCase.getRedefinedElements().contains(useCase2)); + + Signal signal = UML.createSignal(); + assertValid(signal); + useCase.getRedefinedClassifiers().add(signal); + assertSuperset(useCase.getRedefinedElements().contains(signal)); + + Node node = UML.createNode(); + assertValid(node); + useCase.getRedefinedClassifiers().add(node); + assertSuperset(useCase.getRedefinedElements().contains(node)); + + Stereotype stereotype = UML.createStereotype(); + assertValid(stereotype); + useCase.getRedefinedClassifiers().add(stereotype); + assertSuperset(useCase.getRedefinedElements().contains(stereotype)); + + StateMachine stateMachine = UML.createStateMachine(); + assertValid(stateMachine); + useCase.getRedefinedClassifiers().add(stateMachine); + assertSuperset(useCase.getRedefinedElements().contains(stateMachine)); + + Artifact artifact = UML.createArtifact(); + assertValid(artifact); + useCase.getRedefinedClassifiers().add(artifact); + assertSuperset(useCase.getRedefinedElements().contains(artifact)); + + Collaboration collaboration = UML.createCollaboration(); + assertValid(collaboration); + useCase.getRedefinedClassifiers().add(collaboration); + assertSuperset(useCase.getRedefinedElements().contains(collaboration)); + } + + public void testRepresentation() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + CollaborationUse collaborationUse = UML.createCollaborationUse(); + assertValid(collaborationUse); + useCase.setRepresentation(collaborationUse); + assertSuperset( + useCase.getCollaborationUses().contains(collaborationUse)); + } + + public void testSubstitution() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + Substitution substitution = UML.createSubstitution(); + assertValid(substitution); + useCase.getSubstitutions().add(substitution); + assertSuperset(useCase.getOwnedElements().contains(substitution)); + assertSuperset(useCase.getClientDependencies().contains(substitution)); + } + + public void testClassifierBehavior() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + ProtocolStateMachine protocolStateMachine = UML + .createProtocolStateMachine(); + assertValid(protocolStateMachine); + useCase.setClassifierBehavior(protocolStateMachine); + assertSuperset( + useCase.getOwnedBehaviors().contains(protocolStateMachine)); + + StateMachine stateMachine = UML.createStateMachine(); + assertValid(stateMachine); + useCase.setClassifierBehavior(stateMachine); + assertSuperset(useCase.getOwnedBehaviors().contains(stateMachine)); + } + + public void testInterfaceRealization() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + InterfaceRealization interfaceRealization = UML + .createInterfaceRealization(); + assertValid(interfaceRealization); + useCase.getInterfaceRealizations().add(interfaceRealization); + assertSuperset( + useCase.getOwnedElements().contains(interfaceRealization)); + assertSuperset( + useCase.getClientDependencies().contains(interfaceRealization)); + } + + public void testOwnedBehavior() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + ProtocolStateMachine protocolStateMachine = UML + .createProtocolStateMachine(); + assertValid(protocolStateMachine); + useCase.getOwnedBehaviors().add(protocolStateMachine); + assertSuperset( + useCase.getOwnedMembers().contains(protocolStateMachine)); + + StateMachine stateMachine = UML.createStateMachine(); + assertValid(stateMachine); + useCase.getOwnedBehaviors().add(stateMachine); + assertSuperset(useCase.getOwnedMembers().contains(stateMachine)); + } + + public void testExtend() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + Extend extend = UML.createExtend(); + assertValid(extend); + useCase.getExtends().add(extend); + assertSuperset(useCase.getOwnedMembers().contains(extend)); + } + + public void testExtensionPoint() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + ExtensionPoint extensionPoint = UML.createExtensionPoint(); + assertValid(extensionPoint); + useCase.getExtensionPoints().add(extensionPoint); + assertSuperset(useCase.getOwnedMembers().contains(extensionPoint)); + } + + public void testInclude() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + Include include = UML.createInclude(); + assertValid(include); + useCase.getIncludes().add(include); + assertSuperset(useCase.getOwnedMembers().contains(include)); + } + + public void testSubject() { + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + + FunctionBehavior functionBehavior = UML.createFunctionBehavior(); + assertValid(functionBehavior); + useCase.getSubjects().add(functionBehavior); + + Activity activity = UML.createActivity(); + assertValid(activity); + useCase.getSubjects().add(activity); + + Interface interface_ = UML.createInterface(); + assertValid(interface_); + useCase.getSubjects().add(interface_); + + InformationItem informationItem = UML.createInformationItem(); + assertValid(informationItem); + useCase.getSubjects().add(informationItem); + + CommunicationPath communicationPath = UML.createCommunicationPath(); + assertValid(communicationPath); + useCase.getSubjects().add(communicationPath); + + ExecutionEnvironment executionEnvironment = UML + .createExecutionEnvironment(); + assertValid(executionEnvironment); + useCase.getSubjects().add(executionEnvironment); + + Component component = UML.createComponent(); + assertValid(component); + useCase.getSubjects().add(component); + + Interaction interaction = UML.createInteraction(); + assertValid(interaction); + useCase.getSubjects().add(interaction); + + DeploymentSpecification deploymentSpecification = UML + .createDeploymentSpecification(); + assertValid(deploymentSpecification); + useCase.getSubjects().add(deploymentSpecification); + + OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior(); + assertValid(opaqueBehavior); + useCase.getSubjects().add(opaqueBehavior); + + Association association = UML.createAssociation(); + assertValid(association); + useCase.getSubjects().add(association); + + DataType dataType = UML.createDataType(); + assertValid(dataType); + useCase.getSubjects().add(dataType); + + Device device = UML.createDevice(); + assertValid(device); + useCase.getSubjects().add(device); + + Extension extension = UML.createExtension(); + assertValid(extension); + useCase.getSubjects().add(extension); + + AssociationClass associationClass = UML.createAssociationClass(); + assertValid(associationClass); + useCase.getSubjects().add(associationClass); + + org.eclipse.uml2.uml.Class class_ = UML.createClass(); + assertValid(class_); + useCase.getSubjects().add(class_); + + Enumeration enumeration = UML.createEnumeration(); + assertValid(enumeration); + useCase.getSubjects().add(enumeration); + + PrimitiveType primitiveType = UML.createPrimitiveType(); + assertValid(primitiveType); + useCase.getSubjects().add(primitiveType); + + Actor actor = UML.createActor(); + assertValid(actor); + useCase.getSubjects().add(actor); + + ProtocolStateMachine protocolStateMachine = UML + .createProtocolStateMachine(); + assertValid(protocolStateMachine); + useCase.getSubjects().add(protocolStateMachine); + + UseCase useCase2 = UML.createUseCase(); + assertValid(useCase2); + useCase.getSubjects().add(useCase2); + + Signal signal = UML.createSignal(); + assertValid(signal); + useCase.getSubjects().add(signal); + + Node node = UML.createNode(); + assertValid(node); + useCase.getSubjects().add(node); + + Stereotype stereotype = UML.createStereotype(); + assertValid(stereotype); + useCase.getSubjects().add(stereotype); + + StateMachine stateMachine = UML.createStateMachine(); + assertValid(stateMachine); + useCase.getSubjects().add(stateMachine); + + Artifact artifact = UML.createArtifact(); + assertValid(artifact); + useCase.getSubjects().add(artifact); + + Collaboration collaboration = UML.createCollaboration(); + assertValid(collaboration); + useCase.getSubjects().add(collaboration); + } + +} |