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