| /* |
| * 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.ConditionalNode; |
| import org.eclipse.uml2.uml.DataType; |
| import org.eclipse.uml2.uml.DeploymentSpecification; |
| import org.eclipse.uml2.uml.Device; |
| import org.eclipse.uml2.uml.Element; |
| import org.eclipse.uml2.uml.Enumeration; |
| import org.eclipse.uml2.uml.ExecutionEnvironment; |
| import org.eclipse.uml2.uml.ExpansionRegion; |
| import org.eclipse.uml2.uml.Extension; |
| import org.eclipse.uml2.uml.FinalState; |
| import org.eclipse.uml2.uml.FunctionBehavior; |
| import org.eclipse.uml2.uml.InformationItem; |
| import org.eclipse.uml2.uml.Interaction; |
| import org.eclipse.uml2.uml.InteractionOperand; |
| import org.eclipse.uml2.uml.Interface; |
| import org.eclipse.uml2.uml.LoopNode; |
| import org.eclipse.uml2.uml.Model; |
| 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.PrimitiveType; |
| import org.eclipse.uml2.uml.Profile; |
| import org.eclipse.uml2.uml.ProtocolStateMachine; |
| import org.eclipse.uml2.uml.ProtocolTransition; |
| import org.eclipse.uml2.uml.Reception; |
| import org.eclipse.uml2.uml.Region; |
| import org.eclipse.uml2.uml.SequenceNode; |
| import org.eclipse.uml2.uml.Signal; |
| import org.eclipse.uml2.uml.State; |
| import org.eclipse.uml2.uml.StateMachine; |
| import org.eclipse.uml2.uml.Stereotype; |
| import org.eclipse.uml2.uml.StructuredActivityNode; |
| import org.eclipse.uml2.uml.Transition; |
| import org.eclipse.uml2.uml.UseCase; |
| |
| /** |
| * @author Eike Stepper |
| */ |
| public class PackageImportTest |
| extends _Abstract_Compliance_Test_ { |
| |
| public void testEAnnotations() { |
| PackageImport packageImport = UML.createPackageImport(); |
| assertValid(packageImport); |
| |
| EAnnotation eAnnotation = ECORE.createEAnnotation(); |
| assertValid(eAnnotation); |
| packageImport.getEAnnotations().add(eAnnotation); |
| } |
| |
| public void testOwnedComment() { |
| PackageImport packageImport = UML.createPackageImport(); |
| assertValid(packageImport); |
| |
| Comment comment = UML.createComment(); |
| assertValid(comment); |
| packageImport.getOwnedComments().add(comment); |
| assertSuperset(packageImport.getOwnedElements().contains(comment)); |
| } |
| |
| public void testOwnedElement() { |
| PackageImport packageImport = UML.createPackageImport(); |
| assertValid(packageImport); |
| EList<Element> elements = packageImport.getOwnedElements(); |
| EList<Element> elements2 = packageImport.getOwnedElements(); |
| assertSame(elements, elements2); |
| } |
| |
| public void testRelatedElement() { |
| PackageImport packageImport = UML.createPackageImport(); |
| assertValid(packageImport); |
| EList<Element> elements = packageImport.getRelatedElements(); |
| EList<Element> elements2 = packageImport.getRelatedElements(); |
| assertSame(elements, elements2); |
| } |
| |
| public void testSource() { |
| PackageImport packageImport = UML.createPackageImport(); |
| assertValid(packageImport); |
| EList<Element> elements = packageImport.getSources(); |
| EList<Element> elements2 = packageImport.getSources(); |
| assertSame(elements, elements2); |
| } |
| |
| public void testTarget() { |
| PackageImport packageImport = UML.createPackageImport(); |
| assertValid(packageImport); |
| EList<Element> elements = packageImport.getTargets(); |
| EList<Element> elements2 = packageImport.getTargets(); |
| assertSame(elements, elements2); |
| } |
| |
| public void testImportedPackage() { |
| PackageImport packageImport = UML.createPackageImport(); |
| assertValid(packageImport); |
| |
| Profile profile = UML.createProfile(); |
| assertValid(profile); |
| packageImport.setImportedPackage(profile); |
| assertSuperset(packageImport.getTargets().contains(profile)); |
| |
| Model model = UML.createModel(); |
| assertValid(model); |
| packageImport.setImportedPackage(model); |
| assertSuperset(packageImport.getTargets().contains(model)); |
| |
| PackageImport packageImport2 = UML.createPackageImport(); |
| assertValid(packageImport2); |
| |
| org.eclipse.uml2.uml.Package package_ = UML.createPackage(); |
| assertValid(package_); |
| packageImport2.setImportedPackage(package_); |
| assertSuperset(packageImport2.getTargets().contains(package_)); |
| } |
| |
| public void testImportingNamespace() { |
| PackageImport packageImport = UML.createPackageImport(); |
| assertValid(packageImport); |
| |
| FunctionBehavior functionBehavior = UML.createFunctionBehavior(); |
| assertValid(functionBehavior); |
| packageImport.setImportingNamespace(functionBehavior); |
| assertSuperset(packageImport.getSources().contains(functionBehavior)); |
| assertSuperset(packageImport.getOwner() == functionBehavior); |
| |
| Activity activity = UML.createActivity(); |
| assertValid(activity); |
| packageImport.setImportingNamespace(activity); |
| assertSuperset(packageImport.getSources().contains(activity)); |
| assertSuperset(packageImport.getOwner() == activity); |
| |
| PackageImport packageImport2 = UML.createPackageImport(); |
| assertValid(packageImport2); |
| |
| Interface interface_ = UML.createInterface(); |
| assertValid(interface_); |
| packageImport2.setImportingNamespace(interface_); |
| assertSuperset(packageImport2.getSources().contains(interface_)); |
| assertSuperset(packageImport2.getOwner() == interface_); |
| |
| InformationItem informationItem = UML.createInformationItem(); |
| assertValid(informationItem); |
| packageImport2.setImportingNamespace(informationItem); |
| assertSuperset(packageImport2.getSources().contains(informationItem)); |
| assertSuperset(packageImport2.getOwner() == informationItem); |
| |
| PackageImport packageImport3 = UML.createPackageImport(); |
| assertValid(packageImport3); |
| |
| CommunicationPath communicationPath = UML.createCommunicationPath(); |
| assertValid(communicationPath); |
| packageImport3.setImportingNamespace(communicationPath); |
| assertSuperset(packageImport3.getSources().contains(communicationPath)); |
| assertSuperset(packageImport3.getOwner() == communicationPath); |
| |
| Region region = UML.createRegion(); |
| assertValid(region); |
| packageImport3.setImportingNamespace(region); |
| assertSuperset(packageImport3.getSources().contains(region)); |
| assertSuperset(packageImport3.getOwner() == region); |
| |
| PackageImport packageImport4 = UML.createPackageImport(); |
| assertValid(packageImport4); |
| |
| Transition transition = UML.createTransition(); |
| assertValid(transition); |
| packageImport4.setImportingNamespace(transition); |
| assertSuperset(packageImport4.getSources().contains(transition)); |
| assertSuperset(packageImport4.getOwner() == transition); |
| |
| ExecutionEnvironment executionEnvironment = UML |
| .createExecutionEnvironment(); |
| assertValid(executionEnvironment); |
| packageImport4.setImportingNamespace(executionEnvironment); |
| assertSuperset( |
| packageImport4.getSources().contains(executionEnvironment)); |
| assertSuperset(packageImport4.getOwner() == executionEnvironment); |
| |
| PackageImport packageImport5 = UML.createPackageImport(); |
| assertValid(packageImport5); |
| |
| Component component = UML.createComponent(); |
| assertValid(component); |
| packageImport5.setImportingNamespace(component); |
| assertSuperset(packageImport5.getSources().contains(component)); |
| assertSuperset(packageImport5.getOwner() == component); |
| |
| org.eclipse.uml2.uml.Package package_ = UML.createPackage(); |
| assertValid(package_); |
| packageImport5.setImportingNamespace(package_); |
| assertSuperset(packageImport5.getSources().contains(package_)); |
| assertSuperset(packageImport5.getOwner() == package_); |
| |
| PackageImport packageImport6 = UML.createPackageImport(); |
| assertValid(packageImport6); |
| |
| Interaction interaction = UML.createInteraction(); |
| assertValid(interaction); |
| packageImport6.setImportingNamespace(interaction); |
| assertSuperset(packageImport6.getSources().contains(interaction)); |
| assertSuperset(packageImport6.getOwner() == interaction); |
| |
| DeploymentSpecification deploymentSpecification = UML |
| .createDeploymentSpecification(); |
| assertValid(deploymentSpecification); |
| packageImport6.setImportingNamespace(deploymentSpecification); |
| assertSuperset( |
| packageImport6.getSources().contains(deploymentSpecification)); |
| assertSuperset(packageImport6.getOwner() == deploymentSpecification); |
| |
| PackageImport packageImport7 = UML.createPackageImport(); |
| assertValid(packageImport7); |
| |
| OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior(); |
| assertValid(opaqueBehavior); |
| packageImport7.setImportingNamespace(opaqueBehavior); |
| assertSuperset(packageImport7.getSources().contains(opaqueBehavior)); |
| assertSuperset(packageImport7.getOwner() == opaqueBehavior); |
| |
| Association association = UML.createAssociation(); |
| assertValid(association); |
| packageImport7.setImportingNamespace(association); |
| assertSuperset(packageImport7.getSources().contains(association)); |
| assertSuperset(packageImport7.getOwner() == association); |
| |
| PackageImport packageImport8 = UML.createPackageImport(); |
| assertValid(packageImport8); |
| |
| Operation operation = UML.createOperation(); |
| assertValid(operation); |
| packageImport8.setImportingNamespace(operation); |
| assertSuperset(packageImport8.getSources().contains(operation)); |
| assertSuperset(packageImport8.getOwner() == operation); |
| |
| DataType dataType = UML.createDataType(); |
| assertValid(dataType); |
| packageImport8.setImportingNamespace(dataType); |
| assertSuperset(packageImport8.getSources().contains(dataType)); |
| assertSuperset(packageImport8.getOwner() == dataType); |
| |
| PackageImport packageImport9 = UML.createPackageImport(); |
| assertValid(packageImport9); |
| |
| Model model = UML.createModel(); |
| assertValid(model); |
| packageImport9.setImportingNamespace(model); |
| assertSuperset(packageImport9.getSources().contains(model)); |
| assertSuperset(packageImport9.getOwner() == model); |
| |
| Device device = UML.createDevice(); |
| assertValid(device); |
| packageImport9.setImportingNamespace(device); |
| assertSuperset(packageImport9.getSources().contains(device)); |
| assertSuperset(packageImport9.getOwner() == device); |
| |
| PackageImport packageImport10 = UML.createPackageImport(); |
| assertValid(packageImport10); |
| |
| Extension extension = UML.createExtension(); |
| assertValid(extension); |
| packageImport10.setImportingNamespace(extension); |
| assertSuperset(packageImport10.getSources().contains(extension)); |
| assertSuperset(packageImport10.getOwner() == extension); |
| |
| AssociationClass associationClass = UML.createAssociationClass(); |
| assertValid(associationClass); |
| packageImport10.setImportingNamespace(associationClass); |
| assertSuperset(packageImport10.getSources().contains(associationClass)); |
| assertSuperset(packageImport10.getOwner() == associationClass); |
| |
| PackageImport packageImport11 = UML.createPackageImport(); |
| assertValid(packageImport11); |
| |
| ExpansionRegion expansionRegion = UML.createExpansionRegion(); |
| assertValid(expansionRegion); |
| packageImport11.setImportingNamespace(expansionRegion); |
| assertSuperset(packageImport11.getSources().contains(expansionRegion)); |
| assertSuperset(packageImport11.getOwner() == expansionRegion); |
| |
| StructuredActivityNode structuredActivityNode = UML |
| .createStructuredActivityNode(); |
| assertValid(structuredActivityNode); |
| packageImport11.setImportingNamespace(structuredActivityNode); |
| assertSuperset( |
| packageImport11.getSources().contains(structuredActivityNode)); |
| assertSuperset(packageImport11.getOwner() == structuredActivityNode); |
| |
| PackageImport packageImport12 = UML.createPackageImport(); |
| assertValid(packageImport12); |
| |
| FinalState finalState = UML.createFinalState(); |
| assertValid(finalState); |
| packageImport12.setImportingNamespace(finalState); |
| assertSuperset(packageImport12.getSources().contains(finalState)); |
| assertSuperset(packageImport12.getOwner() == finalState); |
| |
| org.eclipse.uml2.uml.Class class_ = UML.createClass(); |
| assertValid(class_); |
| packageImport12.setImportingNamespace(class_); |
| assertSuperset(packageImport12.getSources().contains(class_)); |
| assertSuperset(packageImport12.getOwner() == class_); |
| |
| PackageImport packageImport13 = UML.createPackageImport(); |
| assertValid(packageImport13); |
| |
| State state = UML.createState(); |
| assertValid(state); |
| packageImport13.setImportingNamespace(state); |
| assertSuperset(packageImport13.getSources().contains(state)); |
| assertSuperset(packageImport13.getOwner() == state); |
| |
| ProtocolTransition protocolTransition = UML.createProtocolTransition(); |
| assertValid(protocolTransition); |
| packageImport13.setImportingNamespace(protocolTransition); |
| assertSuperset( |
| packageImport13.getSources().contains(protocolTransition)); |
| assertSuperset(packageImport13.getOwner() == protocolTransition); |
| |
| PackageImport packageImport14 = UML.createPackageImport(); |
| assertValid(packageImport14); |
| |
| Enumeration enumeration = UML.createEnumeration(); |
| assertValid(enumeration); |
| packageImport14.setImportingNamespace(enumeration); |
| assertSuperset(packageImport14.getSources().contains(enumeration)); |
| assertSuperset(packageImport14.getOwner() == enumeration); |
| |
| PrimitiveType primitiveType = UML.createPrimitiveType(); |
| assertValid(primitiveType); |
| packageImport14.setImportingNamespace(primitiveType); |
| assertSuperset(packageImport14.getSources().contains(primitiveType)); |
| assertSuperset(packageImport14.getOwner() == primitiveType); |
| |
| PackageImport packageImport15 = UML.createPackageImport(); |
| assertValid(packageImport15); |
| |
| Actor actor = UML.createActor(); |
| assertValid(actor); |
| packageImport15.setImportingNamespace(actor); |
| assertSuperset(packageImport15.getSources().contains(actor)); |
| assertSuperset(packageImport15.getOwner() == actor); |
| |
| Profile profile = UML.createProfile(); |
| assertValid(profile); |
| packageImport15.setImportingNamespace(profile); |
| assertSuperset(packageImport15.getSources().contains(profile)); |
| assertSuperset(packageImport15.getOwner() == profile); |
| |
| PackageImport packageImport16 = UML.createPackageImport(); |
| assertValid(packageImport16); |
| |
| ProtocolStateMachine protocolStateMachine = UML |
| .createProtocolStateMachine(); |
| assertValid(protocolStateMachine); |
| packageImport16.setImportingNamespace(protocolStateMachine); |
| assertSuperset( |
| packageImport16.getSources().contains(protocolStateMachine)); |
| assertSuperset(packageImport16.getOwner() == protocolStateMachine); |
| |
| LoopNode loopNode = UML.createLoopNode(); |
| assertValid(loopNode); |
| packageImport16.setImportingNamespace(loopNode); |
| assertSuperset(packageImport16.getSources().contains(loopNode)); |
| assertSuperset(packageImport16.getOwner() == loopNode); |
| |
| PackageImport packageImport17 = UML.createPackageImport(); |
| assertValid(packageImport17); |
| |
| InteractionOperand interactionOperand = UML.createInteractionOperand(); |
| assertValid(interactionOperand); |
| packageImport17.setImportingNamespace(interactionOperand); |
| assertSuperset( |
| packageImport17.getSources().contains(interactionOperand)); |
| assertSuperset(packageImport17.getOwner() == interactionOperand); |
| |
| Reception reception = UML.createReception(); |
| assertValid(reception); |
| packageImport17.setImportingNamespace(reception); |
| assertSuperset(packageImport17.getSources().contains(reception)); |
| assertSuperset(packageImport17.getOwner() == reception); |
| |
| PackageImport packageImport18 = UML.createPackageImport(); |
| assertValid(packageImport18); |
| |
| UseCase useCase = UML.createUseCase(); |
| assertValid(useCase); |
| packageImport18.setImportingNamespace(useCase); |
| assertSuperset(packageImport18.getSources().contains(useCase)); |
| assertSuperset(packageImport18.getOwner() == useCase); |
| |
| Signal signal = UML.createSignal(); |
| assertValid(signal); |
| packageImport18.setImportingNamespace(signal); |
| assertSuperset(packageImport18.getSources().contains(signal)); |
| assertSuperset(packageImport18.getOwner() == signal); |
| |
| PackageImport packageImport19 = UML.createPackageImport(); |
| assertValid(packageImport19); |
| |
| Node node = UML.createNode(); |
| assertValid(node); |
| packageImport19.setImportingNamespace(node); |
| assertSuperset(packageImport19.getSources().contains(node)); |
| assertSuperset(packageImport19.getOwner() == node); |
| |
| SequenceNode sequenceNode = UML.createSequenceNode(); |
| assertValid(sequenceNode); |
| packageImport19.setImportingNamespace(sequenceNode); |
| assertSuperset(packageImport19.getSources().contains(sequenceNode)); |
| assertSuperset(packageImport19.getOwner() == sequenceNode); |
| |
| PackageImport packageImport20 = UML.createPackageImport(); |
| assertValid(packageImport20); |
| |
| Stereotype stereotype = UML.createStereotype(); |
| assertValid(stereotype); |
| packageImport20.setImportingNamespace(stereotype); |
| assertSuperset(packageImport20.getSources().contains(stereotype)); |
| assertSuperset(packageImport20.getOwner() == stereotype); |
| |
| ConditionalNode conditionalNode = UML.createConditionalNode(); |
| assertValid(conditionalNode); |
| packageImport20.setImportingNamespace(conditionalNode); |
| assertSuperset(packageImport20.getSources().contains(conditionalNode)); |
| assertSuperset(packageImport20.getOwner() == conditionalNode); |
| |
| PackageImport packageImport21 = UML.createPackageImport(); |
| assertValid(packageImport21); |
| |
| StateMachine stateMachine = UML.createStateMachine(); |
| assertValid(stateMachine); |
| packageImport21.setImportingNamespace(stateMachine); |
| assertSuperset(packageImport21.getSources().contains(stateMachine)); |
| assertSuperset(packageImport21.getOwner() == stateMachine); |
| |
| Artifact artifact = UML.createArtifact(); |
| assertValid(artifact); |
| packageImport21.setImportingNamespace(artifact); |
| assertSuperset(packageImport21.getSources().contains(artifact)); |
| assertSuperset(packageImport21.getOwner() == artifact); |
| |
| PackageImport packageImport22 = UML.createPackageImport(); |
| assertValid(packageImport22); |
| |
| Collaboration collaboration = UML.createCollaboration(); |
| assertValid(collaboration); |
| packageImport22.setImportingNamespace(collaboration); |
| assertSuperset(packageImport22.getSources().contains(collaboration)); |
| assertSuperset(packageImport22.getOwner() == collaboration); |
| } |
| |
| } |