/*
 * 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);
	}

}