diff options
Diffstat (limited to 'cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/EnumerationLiteralTest.java')
| -rwxr-xr-x | cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/EnumerationLiteralTest.java | 418 |
1 files changed, 418 insertions, 0 deletions
diff --git a/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/EnumerationLiteralTest.java b/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/EnumerationLiteralTest.java new file mode 100755 index 00000000..be2c730d --- /dev/null +++ b/cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/EnumerationLiteralTest.java @@ -0,0 +1,418 @@ +/* + * 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.Collaboration; +import org.eclipse.uml2.uml.Comment; +import org.eclipse.uml2.uml.CommunicationPath; +import org.eclipse.uml2.uml.Component; +import org.eclipse.uml2.uml.DataType; +import org.eclipse.uml2.uml.Dependency; +import org.eclipse.uml2.uml.Deployment; +import org.eclipse.uml2.uml.DeploymentSpecification; +import org.eclipse.uml2.uml.Device; +import org.eclipse.uml2.uml.Duration; +import org.eclipse.uml2.uml.DurationInterval; +import org.eclipse.uml2.uml.Element; +import org.eclipse.uml2.uml.Enumeration; +import org.eclipse.uml2.uml.EnumerationLiteral; +import org.eclipse.uml2.uml.ExecutionEnvironment; +import org.eclipse.uml2.uml.Expression; +import org.eclipse.uml2.uml.Extension; +import org.eclipse.uml2.uml.FunctionBehavior; +import org.eclipse.uml2.uml.InformationItem; +import org.eclipse.uml2.uml.InstanceValue; +import org.eclipse.uml2.uml.Interaction; +import org.eclipse.uml2.uml.Interface; +import org.eclipse.uml2.uml.Interval; +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.Node; +import org.eclipse.uml2.uml.OpaqueBehavior; +import org.eclipse.uml2.uml.OpaqueExpression; +import org.eclipse.uml2.uml.PackageableElement; +import org.eclipse.uml2.uml.PrimitiveType; +import org.eclipse.uml2.uml.ProtocolStateMachine; +import org.eclipse.uml2.uml.Signal; +import org.eclipse.uml2.uml.Slot; +import org.eclipse.uml2.uml.StateMachine; +import org.eclipse.uml2.uml.Stereotype; +import org.eclipse.uml2.uml.StringExpression; +import org.eclipse.uml2.uml.TemplateParameter; +import org.eclipse.uml2.uml.TimeExpression; +import org.eclipse.uml2.uml.TimeInterval; +import org.eclipse.uml2.uml.UseCase; + +/** + * @author Eike Stepper + */ +public class EnumerationLiteralTest + extends _Abstract_Compliance_Test_ { + + public void testEAnnotations() { + EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral); + + EAnnotation eAnnotation = ECORE.createEAnnotation(); + assertValid(eAnnotation); + enumerationLiteral.getEAnnotations().add(eAnnotation); + } + + public void testOwnedComment() { + EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral); + + Comment comment = UML.createComment(); + assertValid(comment); + enumerationLiteral.getOwnedComments().add(comment); + assertSuperset(enumerationLiteral.getOwnedElements().contains(comment)); + } + + public void testOwnedElement() { + EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral); + EList<Element> elements = enumerationLiteral.getOwnedElements(); + EList<Element> elements2 = enumerationLiteral.getOwnedElements(); + assertSame(elements, elements2); + } + + public void testClientDependency() { + EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral); + EList<Dependency> dependencys = enumerationLiteral + .getClientDependencies(); + EList<Dependency> dependencys2 = enumerationLiteral + .getClientDependencies(); + assertSame(dependencys, dependencys2); + } + + public void testNameExpression() { + EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral); + + StringExpression stringExpression = UML.createStringExpression(); + assertValid(stringExpression); + enumerationLiteral.setNameExpression(stringExpression); + assertSuperset( + enumerationLiteral.getOwnedElements().contains(stringExpression)); + } + + public void testDeployedElement() { + EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral); + EList<PackageableElement> packageableElements = enumerationLiteral + .getDeployedElements(); + EList<PackageableElement> packageableElements2 = enumerationLiteral + .getDeployedElements(); + assertSame(packageableElements, packageableElements2); + } + + public void testDeployment() { + EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral); + + Deployment deployment = UML.createDeployment(); + assertValid(deployment); + enumerationLiteral.getDeployments().add(deployment); + assertSuperset( + enumerationLiteral.getOwnedElements().contains(deployment)); + assertSuperset( + enumerationLiteral.getClientDependencies().contains(deployment)); + } + + public void testOwningTemplateParameter() { + EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral); + + TemplateParameter templateParameter = UML.createTemplateParameter(); + assertValid(templateParameter); + enumerationLiteral.setOwningTemplateParameter(templateParameter); + assertSuperset(enumerationLiteral.getOwner() == templateParameter); + assertSuperset( + enumerationLiteral.getTemplateParameter() == templateParameter); + } + + public void testTemplateParameter() { + EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral); + + TemplateParameter templateParameter = UML.createTemplateParameter(); + assertValid(templateParameter); + enumerationLiteral.setTemplateParameter(templateParameter); + } + + public void testClassifier() { + EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral); + + FunctionBehavior functionBehavior = UML.createFunctionBehavior(); + assertValid(functionBehavior); + enumerationLiteral.getClassifiers().add(functionBehavior); + + Activity activity = UML.createActivity(); + assertValid(activity); + enumerationLiteral.getClassifiers().add(activity); + + Interface interface_ = UML.createInterface(); + assertValid(interface_); + enumerationLiteral.getClassifiers().add(interface_); + + InformationItem informationItem = UML.createInformationItem(); + assertValid(informationItem); + enumerationLiteral.getClassifiers().add(informationItem); + + CommunicationPath communicationPath = UML.createCommunicationPath(); + assertValid(communicationPath); + enumerationLiteral.getClassifiers().add(communicationPath); + + ExecutionEnvironment executionEnvironment = UML + .createExecutionEnvironment(); + assertValid(executionEnvironment); + enumerationLiteral.getClassifiers().add(executionEnvironment); + + Component component = UML.createComponent(); + assertValid(component); + enumerationLiteral.getClassifiers().add(component); + + Interaction interaction = UML.createInteraction(); + assertValid(interaction); + enumerationLiteral.getClassifiers().add(interaction); + + DeploymentSpecification deploymentSpecification = UML + .createDeploymentSpecification(); + assertValid(deploymentSpecification); + enumerationLiteral.getClassifiers().add(deploymentSpecification); + + OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior(); + assertValid(opaqueBehavior); + enumerationLiteral.getClassifiers().add(opaqueBehavior); + + Association association = UML.createAssociation(); + assertValid(association); + enumerationLiteral.getClassifiers().add(association); + + DataType dataType = UML.createDataType(); + assertValid(dataType); + enumerationLiteral.getClassifiers().add(dataType); + + Device device = UML.createDevice(); + assertValid(device); + enumerationLiteral.getClassifiers().add(device); + + Extension extension = UML.createExtension(); + assertValid(extension); + enumerationLiteral.getClassifiers().add(extension); + + AssociationClass associationClass = UML.createAssociationClass(); + assertValid(associationClass); + enumerationLiteral.getClassifiers().add(associationClass); + + org.eclipse.uml2.uml.Class class_ = UML.createClass(); + assertValid(class_); + enumerationLiteral.getClassifiers().add(class_); + + Enumeration enumeration = UML.createEnumeration(); + assertValid(enumeration); + enumerationLiteral.getClassifiers().add(enumeration); + + PrimitiveType primitiveType = UML.createPrimitiveType(); + assertValid(primitiveType); + enumerationLiteral.getClassifiers().add(primitiveType); + + Actor actor = UML.createActor(); + assertValid(actor); + enumerationLiteral.getClassifiers().add(actor); + + ProtocolStateMachine protocolStateMachine = UML + .createProtocolStateMachine(); + assertValid(protocolStateMachine); + enumerationLiteral.getClassifiers().add(protocolStateMachine); + + UseCase useCase = UML.createUseCase(); + assertValid(useCase); + enumerationLiteral.getClassifiers().add(useCase); + + Signal signal = UML.createSignal(); + assertValid(signal); + enumerationLiteral.getClassifiers().add(signal); + + Node node = UML.createNode(); + assertValid(node); + enumerationLiteral.getClassifiers().add(node); + + Stereotype stereotype = UML.createStereotype(); + assertValid(stereotype); + enumerationLiteral.getClassifiers().add(stereotype); + + StateMachine stateMachine = UML.createStateMachine(); + assertValid(stateMachine); + enumerationLiteral.getClassifiers().add(stateMachine); + + Artifact artifact = UML.createArtifact(); + assertValid(artifact); + enumerationLiteral.getClassifiers().add(artifact); + + Collaboration collaboration = UML.createCollaboration(); + assertValid(collaboration); + enumerationLiteral.getClassifiers().add(collaboration); + } + + public void testSlot() { + EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral); + + Slot slot = UML.createSlot(); + assertValid(slot); + enumerationLiteral.getSlots().add(slot); + assertSuperset(enumerationLiteral.getOwnedElements().contains(slot)); + } + + public void testSpecification() { + EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral); + + LiteralBoolean literalBoolean = UML.createLiteralBoolean(); + assertValid(literalBoolean); + enumerationLiteral.setSpecification(literalBoolean); + assertSuperset( + enumerationLiteral.getOwnedElements().contains(literalBoolean)); + + Interval interval = UML.createInterval(); + assertValid(interval); + enumerationLiteral.setSpecification(interval); + assertSuperset( + enumerationLiteral.getOwnedElements().contains(interval)); + + EnumerationLiteral enumerationLiteral2 = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral2); + + OpaqueExpression opaqueExpression = UML.createOpaqueExpression(); + assertValid(opaqueExpression); + enumerationLiteral2.setSpecification(opaqueExpression); + assertSuperset( + enumerationLiteral2.getOwnedElements().contains(opaqueExpression)); + + Expression expression = UML.createExpression(); + assertValid(expression); + enumerationLiteral2.setSpecification(expression); + assertSuperset( + enumerationLiteral2.getOwnedElements().contains(expression)); + + EnumerationLiteral enumerationLiteral3 = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral3); + + LiteralReal literalReal = UML.createLiteralReal(); + assertValid(literalReal); + enumerationLiteral3.setSpecification(literalReal); + assertSuperset( + enumerationLiteral3.getOwnedElements().contains(literalReal)); + + LiteralString literalString = UML.createLiteralString(); + assertValid(literalString); + enumerationLiteral3.setSpecification(literalString); + assertSuperset( + enumerationLiteral3.getOwnedElements().contains(literalString)); + + EnumerationLiteral enumerationLiteral4 = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral4); + + LiteralNull literalNull = UML.createLiteralNull(); + assertValid(literalNull); + enumerationLiteral4.setSpecification(literalNull); + assertSuperset( + enumerationLiteral4.getOwnedElements().contains(literalNull)); + + Duration duration = UML.createDuration(); + assertValid(duration); + enumerationLiteral4.setSpecification(duration); + assertSuperset( + enumerationLiteral4.getOwnedElements().contains(duration)); + + EnumerationLiteral enumerationLiteral5 = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral5); + + LiteralInteger literalInteger = UML.createLiteralInteger(); + assertValid(literalInteger); + enumerationLiteral5.setSpecification(literalInteger); + assertSuperset( + enumerationLiteral5.getOwnedElements().contains(literalInteger)); + + DurationInterval durationInterval = UML.createDurationInterval(); + assertValid(durationInterval); + enumerationLiteral5.setSpecification(durationInterval); + assertSuperset( + enumerationLiteral5.getOwnedElements().contains(durationInterval)); + + EnumerationLiteral enumerationLiteral6 = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral6); + + StringExpression stringExpression = UML.createStringExpression(); + assertValid(stringExpression); + enumerationLiteral6.setSpecification(stringExpression); + assertSuperset( + enumerationLiteral6.getOwnedElements().contains(stringExpression)); + + LiteralUnlimitedNatural literalUnlimitedNatural = UML + .createLiteralUnlimitedNatural(); + assertValid(literalUnlimitedNatural); + enumerationLiteral6.setSpecification(literalUnlimitedNatural); + assertSuperset(enumerationLiteral6.getOwnedElements() + .contains(literalUnlimitedNatural)); + + EnumerationLiteral enumerationLiteral7 = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral7); + + TimeInterval timeInterval = UML.createTimeInterval(); + assertValid(timeInterval); + enumerationLiteral7.setSpecification(timeInterval); + assertSuperset( + enumerationLiteral7.getOwnedElements().contains(timeInterval)); + + TimeExpression timeExpression = UML.createTimeExpression(); + assertValid(timeExpression); + enumerationLiteral7.setSpecification(timeExpression); + assertSuperset( + enumerationLiteral7.getOwnedElements().contains(timeExpression)); + + EnumerationLiteral enumerationLiteral8 = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral8); + + InstanceValue instanceValue = UML.createInstanceValue(); + assertValid(instanceValue); + enumerationLiteral8.setSpecification(instanceValue); + assertSuperset( + enumerationLiteral8.getOwnedElements().contains(instanceValue)); + } + + public void testEnumeration() { + EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral(); + assertValid(enumerationLiteral); + + Enumeration enumeration = UML.createEnumeration(); + assertValid(enumeration); + enumerationLiteral.setEnumeration(enumeration); + assertSuperset(enumerationLiteral.getNamespace() == enumeration); + } + +} |