cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ConnectorTest.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.Association;
import org.eclipse.uml2.uml.AssociationClass;
import org.eclipse.uml2.uml.Classifier;
import org.eclipse.uml2.uml.Comment;
import org.eclipse.uml2.uml.CommunicationPath;
import org.eclipse.uml2.uml.Connector;
import org.eclipse.uml2.uml.ConnectorEnd;
import org.eclipse.uml2.uml.Dependency;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.Extension;
import org.eclipse.uml2.uml.ProtocolStateMachine;
import org.eclipse.uml2.uml.RedefinableElement;
import org.eclipse.uml2.uml.StateMachine;
import org.eclipse.uml2.uml.StringExpression;

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

	public void testEAnnotations() {
		Connector connector = UML.createConnector();
		assertValid(connector);

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

	public void testOwnedComment() {
		Connector connector = UML.createConnector();
		assertValid(connector);

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

	public void testOwnedElement() {
		Connector connector = UML.createConnector();
		assertValid(connector);
		EList<Element> elements = connector.getOwnedElements();
		EList<Element> elements2 = connector.getOwnedElements();
		assertSame(elements, elements2);
	}

	public void testClientDependency() {
		Connector connector = UML.createConnector();
		assertValid(connector);
		EList<Dependency> dependencys = connector.getClientDependencies();
		EList<Dependency> dependencys2 = connector.getClientDependencies();
		assertSame(dependencys, dependencys2);
	}

	public void testNameExpression() {
		Connector connector = UML.createConnector();
		assertValid(connector);

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

	public void testRedefinedElement() {
		Connector connector = UML.createConnector();
		assertValid(connector);
		EList<RedefinableElement> redefinableElements = connector
			.getRedefinedElements();
		EList<RedefinableElement> redefinableElements2 = connector
			.getRedefinedElements();
		assertSame(redefinableElements, redefinableElements2);
	}

	public void testRedefinitionContext() {
		Connector connector = UML.createConnector();
		assertValid(connector);
		EList<Classifier> classifiers = connector.getRedefinitionContexts();
		EList<Classifier> classifiers2 = connector.getRedefinitionContexts();
		assertSame(classifiers, classifiers2);
	}

	public void testFeaturingClassifier() {
		Connector connector = UML.createConnector();
		assertValid(connector);
		EList<Classifier> classifiers = connector.getFeaturingClassifiers();
		EList<Classifier> classifiers2 = connector.getFeaturingClassifiers();
		assertSame(classifiers, classifiers2);
	}

	public void testContract() {
		Connector connector = UML.createConnector();
		assertValid(connector);

		ProtocolStateMachine protocolStateMachine = UML
			.createProtocolStateMachine();
		assertValid(protocolStateMachine);
		connector.getContracts().add(protocolStateMachine);

		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		connector.getContracts().add(stateMachine);
	}

	public void testEnd() {
		Connector connector = UML.createConnector();
		assertValid(connector);

		ConnectorEnd connectorEnd = UML.createConnectorEnd();
		assertValid(connectorEnd);
		connector.getEnds().add(connectorEnd);
		assertSuperset(connector.getOwnedElements().contains(connectorEnd));

		ConnectorEnd connectorEnd2 = UML.createConnectorEnd();
		assertValid(connectorEnd2);
		connector.getEnds().add(connectorEnd2);
		assertSuperset(connector.getOwnedElements().contains(connectorEnd2));
	}

	public void testRedefinedConnector() {
		Connector connector = UML.createConnector();
		assertValid(connector);

		Connector connector2 = UML.createConnector();
		assertValid(connector2);
		connector.getRedefinedConnectors().add(connector2);
		assertSuperset(connector.getRedefinedElements().contains(connector2));
	}

	public void testType() {
		Connector connector = UML.createConnector();
		assertValid(connector);

		Extension extension = UML.createExtension();
		assertValid(extension);
		connector.setType(extension);

		AssociationClass associationClass = UML.createAssociationClass();
		assertValid(associationClass);
		connector.setType(associationClass);

		Connector connector2 = UML.createConnector();
		assertValid(connector2);

		CommunicationPath communicationPath = UML.createCommunicationPath();
		assertValid(communicationPath);
		connector2.setType(communicationPath);

		Association association = UML.createAssociation();
		assertValid(association);
		connector2.setType(association);
	}

}