cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/RedefinableTemplateSignatureTest.java

/*
 * 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.Comment;
import org.eclipse.uml2.uml.CommunicationPath;
import org.eclipse.uml2.uml.Component;
import org.eclipse.uml2.uml.ConnectableElementTemplateParameter;
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.Element;
import org.eclipse.uml2.uml.Enumeration;
import org.eclipse.uml2.uml.ExecutionEnvironment;
import org.eclipse.uml2.uml.Extension;
import org.eclipse.uml2.uml.FunctionBehavior;
import org.eclipse.uml2.uml.InformationItem;
import org.eclipse.uml2.uml.Interaction;
import org.eclipse.uml2.uml.Interface;
import org.eclipse.uml2.uml.Node;
import org.eclipse.uml2.uml.OpaqueBehavior;
import org.eclipse.uml2.uml.OperationTemplateParameter;
import org.eclipse.uml2.uml.PrimitiveType;
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.TemplateParameter;
import org.eclipse.uml2.uml.UseCase;

/**
 * @author Eike Stepper
 */
public class RedefinableTemplateSignatureTest
		extends _Abstract_Compliance_Test_ {

	public void testEAnnotations() {
		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);

		EAnnotation eAnnotation = ECORE.createEAnnotation();
		assertValid(eAnnotation);
		redefinableTemplateSignature.getEAnnotations().add(eAnnotation);
	}

	public void testOwnedComment() {
		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);

		Comment comment = UML.createComment();
		assertValid(comment);
		redefinableTemplateSignature.getOwnedComments().add(comment);
		assertSuperset(
			redefinableTemplateSignature.getOwnedElements().contains(comment));
	}

	public void testOwnedElement() {
		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);
		EList<Element> elements = redefinableTemplateSignature
			.getOwnedElements();
		EList<Element> elements2 = redefinableTemplateSignature
			.getOwnedElements();
		assertSame(elements, elements2);
	}

	public void testClientDependency() {
		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);
		EList<Dependency> dependencys = redefinableTemplateSignature
			.getClientDependencies();
		EList<Dependency> dependencys2 = redefinableTemplateSignature
			.getClientDependencies();
		assertSame(dependencys, dependencys2);
	}

	public void testNameExpression() {
		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);

		StringExpression stringExpression = UML.createStringExpression();
		assertValid(stringExpression);
		redefinableTemplateSignature.setNameExpression(stringExpression);
		assertSuperset(redefinableTemplateSignature.getOwnedElements()
			.contains(stringExpression));
	}

	public void testRedefinedElement() {
		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);
		EList<RedefinableElement> redefinableElements = redefinableTemplateSignature
			.getRedefinedElements();
		EList<RedefinableElement> redefinableElements2 = redefinableTemplateSignature
			.getRedefinedElements();
		assertSame(redefinableElements, redefinableElements2);
	}

	public void testRedefinitionContext() {
		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);
		EList<Classifier> classifiers = redefinableTemplateSignature
			.getRedefinitionContexts();
		EList<Classifier> classifiers2 = redefinableTemplateSignature
			.getRedefinitionContexts();
		assertSame(classifiers, classifiers2);
	}

	public void testParameter() {
		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);

		ClassifierTemplateParameter classifierTemplateParameter = UML
			.createClassifierTemplateParameter();
		assertValid(classifierTemplateParameter);
		redefinableTemplateSignature.getParameters()
			.add(classifierTemplateParameter);

		ConnectableElementTemplateParameter connectableElementTemplateParameter = UML
			.createConnectableElementTemplateParameter();
		assertValid(connectableElementTemplateParameter);
		redefinableTemplateSignature.getParameters()
			.add(connectableElementTemplateParameter);

		TemplateParameter templateParameter = UML.createTemplateParameter();
		assertValid(templateParameter);
		redefinableTemplateSignature.getParameters().add(templateParameter);

		OperationTemplateParameter operationTemplateParameter = UML
			.createOperationTemplateParameter();
		assertValid(operationTemplateParameter);
		redefinableTemplateSignature.getParameters()
			.add(operationTemplateParameter);
	}

	public void testTemplate() {
		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);

		FunctionBehavior functionBehavior = UML.createFunctionBehavior();
		assertValid(functionBehavior);
		redefinableTemplateSignature.setTemplate(functionBehavior);
		assertSuperset(
			redefinableTemplateSignature.getOwner() == functionBehavior);

		Activity activity = UML.createActivity();
		assertValid(activity);
		redefinableTemplateSignature.setTemplate(activity);
		assertSuperset(redefinableTemplateSignature.getOwner() == activity);

		RedefinableTemplateSignature redefinableTemplateSignature2 = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature2);

		Interface interface_ = UML.createInterface();
		assertValid(interface_);
		redefinableTemplateSignature2.setTemplate(interface_);
		assertSuperset(redefinableTemplateSignature2.getOwner() == interface_);

		InformationItem informationItem = UML.createInformationItem();
		assertValid(informationItem);
		redefinableTemplateSignature2.setTemplate(informationItem);
		assertSuperset(
			redefinableTemplateSignature2.getOwner() == informationItem);

		RedefinableTemplateSignature redefinableTemplateSignature3 = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature3);

		CommunicationPath communicationPath = UML.createCommunicationPath();
		assertValid(communicationPath);
		redefinableTemplateSignature3.setTemplate(communicationPath);
		assertSuperset(
			redefinableTemplateSignature3.getOwner() == communicationPath);

		ExecutionEnvironment executionEnvironment = UML
			.createExecutionEnvironment();
		assertValid(executionEnvironment);
		redefinableTemplateSignature3.setTemplate(executionEnvironment);
		assertSuperset(
			redefinableTemplateSignature3.getOwner() == executionEnvironment);

		RedefinableTemplateSignature redefinableTemplateSignature4 = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature4);

		Component component = UML.createComponent();
		assertValid(component);
		redefinableTemplateSignature4.setTemplate(component);
		assertSuperset(redefinableTemplateSignature4.getOwner() == component);

		Interaction interaction = UML.createInteraction();
		assertValid(interaction);
		redefinableTemplateSignature4.setTemplate(interaction);
		assertSuperset(redefinableTemplateSignature4.getOwner() == interaction);

		RedefinableTemplateSignature redefinableTemplateSignature5 = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature5);

		DeploymentSpecification deploymentSpecification = UML
			.createDeploymentSpecification();
		assertValid(deploymentSpecification);
		redefinableTemplateSignature5.setTemplate(deploymentSpecification);
		assertSuperset(redefinableTemplateSignature5
			.getOwner() == deploymentSpecification);

		OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior();
		assertValid(opaqueBehavior);
		redefinableTemplateSignature5.setTemplate(opaqueBehavior);
		assertSuperset(
			redefinableTemplateSignature5.getOwner() == opaqueBehavior);

		RedefinableTemplateSignature redefinableTemplateSignature6 = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature6);

		Association association = UML.createAssociation();
		assertValid(association);
		redefinableTemplateSignature6.setTemplate(association);
		assertSuperset(redefinableTemplateSignature6.getOwner() == association);

		DataType dataType = UML.createDataType();
		assertValid(dataType);
		redefinableTemplateSignature6.setTemplate(dataType);
		assertSuperset(redefinableTemplateSignature6.getOwner() == dataType);

		RedefinableTemplateSignature redefinableTemplateSignature7 = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature7);

		Device device = UML.createDevice();
		assertValid(device);
		redefinableTemplateSignature7.setTemplate(device);
		assertSuperset(redefinableTemplateSignature7.getOwner() == device);

		Extension extension = UML.createExtension();
		assertValid(extension);
		redefinableTemplateSignature7.setTemplate(extension);
		assertSuperset(redefinableTemplateSignature7.getOwner() == extension);

		RedefinableTemplateSignature redefinableTemplateSignature8 = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature8);

		AssociationClass associationClass = UML.createAssociationClass();
		assertValid(associationClass);
		redefinableTemplateSignature8.setTemplate(associationClass);
		assertSuperset(
			redefinableTemplateSignature8.getOwner() == associationClass);

		org.eclipse.uml2.uml.Class class_ = UML.createClass();
		assertValid(class_);
		redefinableTemplateSignature8.setTemplate(class_);
		assertSuperset(redefinableTemplateSignature8.getOwner() == class_);

		RedefinableTemplateSignature redefinableTemplateSignature9 = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature9);

		Enumeration enumeration = UML.createEnumeration();
		assertValid(enumeration);
		redefinableTemplateSignature9.setTemplate(enumeration);
		assertSuperset(redefinableTemplateSignature9.getOwner() == enumeration);

		PrimitiveType primitiveType = UML.createPrimitiveType();
		assertValid(primitiveType);
		redefinableTemplateSignature9.setTemplate(primitiveType);
		assertSuperset(
			redefinableTemplateSignature9.getOwner() == primitiveType);

		RedefinableTemplateSignature redefinableTemplateSignature10 = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature10);

		Actor actor = UML.createActor();
		assertValid(actor);
		redefinableTemplateSignature10.setTemplate(actor);
		assertSuperset(redefinableTemplateSignature10.getOwner() == actor);

		ProtocolStateMachine protocolStateMachine = UML
			.createProtocolStateMachine();
		assertValid(protocolStateMachine);
		redefinableTemplateSignature10.setTemplate(protocolStateMachine);
		assertSuperset(
			redefinableTemplateSignature10.getOwner() == protocolStateMachine);

		RedefinableTemplateSignature redefinableTemplateSignature11 = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature11);

		UseCase useCase = UML.createUseCase();
		assertValid(useCase);
		redefinableTemplateSignature11.setTemplate(useCase);
		assertSuperset(redefinableTemplateSignature11.getOwner() == useCase);

		Signal signal = UML.createSignal();
		assertValid(signal);
		redefinableTemplateSignature11.setTemplate(signal);
		assertSuperset(redefinableTemplateSignature11.getOwner() == signal);

		RedefinableTemplateSignature redefinableTemplateSignature12 = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature12);

		Node node = UML.createNode();
		assertValid(node);
		redefinableTemplateSignature12.setTemplate(node);
		assertSuperset(redefinableTemplateSignature12.getOwner() == node);

		Stereotype stereotype = UML.createStereotype();
		assertValid(stereotype);
		redefinableTemplateSignature12.setTemplate(stereotype);
		assertSuperset(redefinableTemplateSignature12.getOwner() == stereotype);

		RedefinableTemplateSignature redefinableTemplateSignature13 = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature13);

		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		redefinableTemplateSignature13.setTemplate(stateMachine);
		assertSuperset(
			redefinableTemplateSignature13.getOwner() == stateMachine);

		Artifact artifact = UML.createArtifact();
		assertValid(artifact);
		redefinableTemplateSignature13.setTemplate(artifact);
		assertSuperset(redefinableTemplateSignature13.getOwner() == artifact);

		RedefinableTemplateSignature redefinableTemplateSignature14 = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature14);

		Collaboration collaboration = UML.createCollaboration();
		assertValid(collaboration);
		redefinableTemplateSignature14.setTemplate(collaboration);
		assertSuperset(
			redefinableTemplateSignature14.getOwner() == collaboration);
	}

	public void testOwnedParameter() {
		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);

		ClassifierTemplateParameter classifierTemplateParameter = UML
			.createClassifierTemplateParameter();
		assertValid(classifierTemplateParameter);
		redefinableTemplateSignature.getOwnedParameters()
			.add(classifierTemplateParameter);
		assertSuperset(redefinableTemplateSignature.getOwnedElements()
			.contains(classifierTemplateParameter));
		assertSuperset(redefinableTemplateSignature.getParameters()
			.contains(classifierTemplateParameter));

		ConnectableElementTemplateParameter connectableElementTemplateParameter = UML
			.createConnectableElementTemplateParameter();
		assertValid(connectableElementTemplateParameter);
		redefinableTemplateSignature.getOwnedParameters()
			.add(connectableElementTemplateParameter);
		assertSuperset(redefinableTemplateSignature.getOwnedElements()
			.contains(connectableElementTemplateParameter));
		assertSuperset(redefinableTemplateSignature.getParameters()
			.contains(connectableElementTemplateParameter));

		TemplateParameter templateParameter = UML.createTemplateParameter();
		assertValid(templateParameter);
		redefinableTemplateSignature.getOwnedParameters()
			.add(templateParameter);
		assertSuperset(redefinableTemplateSignature.getOwnedElements()
			.contains(templateParameter));
		assertSuperset(redefinableTemplateSignature.getParameters()
			.contains(templateParameter));

		OperationTemplateParameter operationTemplateParameter = UML
			.createOperationTemplateParameter();
		assertValid(operationTemplateParameter);
		redefinableTemplateSignature.getOwnedParameters()
			.add(operationTemplateParameter);
		assertSuperset(redefinableTemplateSignature.getOwnedElements()
			.contains(operationTemplateParameter));
		assertSuperset(redefinableTemplateSignature.getParameters()
			.contains(operationTemplateParameter));
	}

	public void testExtendedSignature() {
		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);

		RedefinableTemplateSignature redefinableTemplateSignature2 = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature2);
		redefinableTemplateSignature.getExtendedSignatures()
			.add(redefinableTemplateSignature2);
		assertSuperset(redefinableTemplateSignature.getRedefinedElements()
			.contains(redefinableTemplateSignature2));
	}

	public void testInheritedParameter() {
		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);
		EList<TemplateParameter> templateParameters = redefinableTemplateSignature
			.getInheritedParameters();
		EList<TemplateParameter> templateParameters2 = redefinableTemplateSignature
			.getInheritedParameters();
		assertSame(templateParameters, templateParameters2);
	}

}