cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/ChangeEventTest.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.ChangeEvent;
import org.eclipse.uml2.uml.Comment;
import org.eclipse.uml2.uml.Dependency;
import org.eclipse.uml2.uml.Duration;
import org.eclipse.uml2.uml.DurationInterval;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.Expression;
import org.eclipse.uml2.uml.InstanceValue;
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.OpaqueExpression;
import org.eclipse.uml2.uml.StringExpression;
import org.eclipse.uml2.uml.TemplateParameter;
import org.eclipse.uml2.uml.TimeExpression;
import org.eclipse.uml2.uml.TimeInterval;

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

	public void testEAnnotations() {
		ChangeEvent changeEvent = UML.createChangeEvent();
		assertValid(changeEvent);

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

	public void testOwnedComment() {
		ChangeEvent changeEvent = UML.createChangeEvent();
		assertValid(changeEvent);

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

	public void testOwnedElement() {
		ChangeEvent changeEvent = UML.createChangeEvent();
		assertValid(changeEvent);
		EList<Element> elements = changeEvent.getOwnedElements();
		EList<Element> elements2 = changeEvent.getOwnedElements();
		assertSame(elements, elements2);
	}

	public void testClientDependency() {
		ChangeEvent changeEvent = UML.createChangeEvent();
		assertValid(changeEvent);
		EList<Dependency> dependencys = changeEvent.getClientDependencies();
		EList<Dependency> dependencys2 = changeEvent.getClientDependencies();
		assertSame(dependencys, dependencys2);
	}

	public void testNameExpression() {
		ChangeEvent changeEvent = UML.createChangeEvent();
		assertValid(changeEvent);

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

	public void testOwningTemplateParameter() {
		ChangeEvent changeEvent = UML.createChangeEvent();
		assertValid(changeEvent);

		TemplateParameter templateParameter = UML.createTemplateParameter();
		assertValid(templateParameter);
		changeEvent.setOwningTemplateParameter(templateParameter);
		assertSuperset(changeEvent.getOwner() == templateParameter);
		assertSuperset(changeEvent.getTemplateParameter() == templateParameter);
	}

	public void testTemplateParameter() {
		ChangeEvent changeEvent = UML.createChangeEvent();
		assertValid(changeEvent);

		TemplateParameter templateParameter = UML.createTemplateParameter();
		assertValid(templateParameter);
		changeEvent.setTemplateParameter(templateParameter);
	}

	public void testChangeExpression() {
		ChangeEvent changeEvent = UML.createChangeEvent();
		assertValid(changeEvent);

		LiteralBoolean literalBoolean = UML.createLiteralBoolean();
		assertValid(literalBoolean);
		changeEvent.setChangeExpression(literalBoolean);
		assertSuperset(changeEvent.getOwnedElements().contains(literalBoolean));

		Interval interval = UML.createInterval();
		assertValid(interval);
		changeEvent.setChangeExpression(interval);
		assertSuperset(changeEvent.getOwnedElements().contains(interval));

		ChangeEvent changeEvent2 = UML.createChangeEvent();
		assertValid(changeEvent2);

		OpaqueExpression opaqueExpression = UML.createOpaqueExpression();
		assertValid(opaqueExpression);
		changeEvent2.setChangeExpression(opaqueExpression);
		assertSuperset(
			changeEvent2.getOwnedElements().contains(opaqueExpression));

		Expression expression = UML.createExpression();
		assertValid(expression);
		changeEvent2.setChangeExpression(expression);
		assertSuperset(changeEvent2.getOwnedElements().contains(expression));

		ChangeEvent changeEvent3 = UML.createChangeEvent();
		assertValid(changeEvent3);

		LiteralReal literalReal = UML.createLiteralReal();
		assertValid(literalReal);
		changeEvent3.setChangeExpression(literalReal);
		assertSuperset(changeEvent3.getOwnedElements().contains(literalReal));

		LiteralString literalString = UML.createLiteralString();
		assertValid(literalString);
		changeEvent3.setChangeExpression(literalString);
		assertSuperset(changeEvent3.getOwnedElements().contains(literalString));

		ChangeEvent changeEvent4 = UML.createChangeEvent();
		assertValid(changeEvent4);

		LiteralNull literalNull = UML.createLiteralNull();
		assertValid(literalNull);
		changeEvent4.setChangeExpression(literalNull);
		assertSuperset(changeEvent4.getOwnedElements().contains(literalNull));

		Duration duration = UML.createDuration();
		assertValid(duration);
		changeEvent4.setChangeExpression(duration);
		assertSuperset(changeEvent4.getOwnedElements().contains(duration));

		ChangeEvent changeEvent5 = UML.createChangeEvent();
		assertValid(changeEvent5);

		LiteralInteger literalInteger = UML.createLiteralInteger();
		assertValid(literalInteger);
		changeEvent5.setChangeExpression(literalInteger);
		assertSuperset(
			changeEvent5.getOwnedElements().contains(literalInteger));

		DurationInterval durationInterval = UML.createDurationInterval();
		assertValid(durationInterval);
		changeEvent5.setChangeExpression(durationInterval);
		assertSuperset(
			changeEvent5.getOwnedElements().contains(durationInterval));

		ChangeEvent changeEvent6 = UML.createChangeEvent();
		assertValid(changeEvent6);

		StringExpression stringExpression = UML.createStringExpression();
		assertValid(stringExpression);
		changeEvent6.setChangeExpression(stringExpression);
		assertSuperset(
			changeEvent6.getOwnedElements().contains(stringExpression));

		LiteralUnlimitedNatural literalUnlimitedNatural = UML
			.createLiteralUnlimitedNatural();
		assertValid(literalUnlimitedNatural);
		changeEvent6.setChangeExpression(literalUnlimitedNatural);
		assertSuperset(
			changeEvent6.getOwnedElements().contains(literalUnlimitedNatural));

		ChangeEvent changeEvent7 = UML.createChangeEvent();
		assertValid(changeEvent7);

		TimeInterval timeInterval = UML.createTimeInterval();
		assertValid(timeInterval);
		changeEvent7.setChangeExpression(timeInterval);
		assertSuperset(changeEvent7.getOwnedElements().contains(timeInterval));

		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);
		changeEvent7.setChangeExpression(timeExpression);
		assertSuperset(
			changeEvent7.getOwnedElements().contains(timeExpression));

		ChangeEvent changeEvent8 = UML.createChangeEvent();
		assertValid(changeEvent8);

		InstanceValue instanceValue = UML.createInstanceValue();
		assertValid(instanceValue);
		changeEvent8.setChangeExpression(instanceValue);
		assertSuperset(changeEvent8.getOwnedElements().contains(instanceValue));
	}

}