cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/LifelineTest.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.ActionExecutionSpecification;
import org.eclipse.uml2.uml.BehaviorExecutionSpecification;
import org.eclipse.uml2.uml.CombinedFragment;
import org.eclipse.uml2.uml.Comment;
import org.eclipse.uml2.uml.ConsiderIgnoreFragment;
import org.eclipse.uml2.uml.Continuation;
import org.eclipse.uml2.uml.Dependency;
import org.eclipse.uml2.uml.DestructionOccurrenceSpecification;
import org.eclipse.uml2.uml.Duration;
import org.eclipse.uml2.uml.DurationInterval;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.ExecutionOccurrenceSpecification;
import org.eclipse.uml2.uml.Expression;
import org.eclipse.uml2.uml.ExtensionEnd;
import org.eclipse.uml2.uml.InstanceValue;
import org.eclipse.uml2.uml.Interaction;
import org.eclipse.uml2.uml.InteractionOperand;
import org.eclipse.uml2.uml.InteractionUse;
import org.eclipse.uml2.uml.Interval;
import org.eclipse.uml2.uml.Lifeline;
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.MessageOccurrenceSpecification;
import org.eclipse.uml2.uml.OccurrenceSpecification;
import org.eclipse.uml2.uml.OpaqueExpression;
import org.eclipse.uml2.uml.Parameter;
import org.eclipse.uml2.uml.PartDecomposition;
import org.eclipse.uml2.uml.Port;
import org.eclipse.uml2.uml.Property;
import org.eclipse.uml2.uml.StateInvariant;
import org.eclipse.uml2.uml.StringExpression;
import org.eclipse.uml2.uml.TimeExpression;
import org.eclipse.uml2.uml.TimeInterval;
import org.eclipse.uml2.uml.Variable;

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

	public void testEAnnotations() {
		Lifeline lifeline = UML.createLifeline();
		assertValid(lifeline);

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

	public void testOwnedComment() {
		Lifeline lifeline = UML.createLifeline();
		assertValid(lifeline);

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

	public void testOwnedElement() {
		Lifeline lifeline = UML.createLifeline();
		assertValid(lifeline);
		EList<Element> elements = lifeline.getOwnedElements();
		EList<Element> elements2 = lifeline.getOwnedElements();
		assertSame(elements, elements2);
	}

	public void testClientDependency() {
		Lifeline lifeline = UML.createLifeline();
		assertValid(lifeline);
		EList<Dependency> dependencys = lifeline.getClientDependencies();
		EList<Dependency> dependencys2 = lifeline.getClientDependencies();
		assertSame(dependencys, dependencys2);
	}

	public void testNameExpression() {
		Lifeline lifeline = UML.createLifeline();
		assertValid(lifeline);

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

	public void testDecomposedAs() {
		Lifeline lifeline = UML.createLifeline();
		assertValid(lifeline);

		PartDecomposition partDecomposition = UML.createPartDecomposition();
		assertValid(partDecomposition);
		lifeline.setDecomposedAs(partDecomposition);
	}

	public void testInteraction() {
		Lifeline lifeline = UML.createLifeline();
		assertValid(lifeline);

		Interaction interaction = UML.createInteraction();
		assertValid(interaction);
		lifeline.setInteraction(interaction);
		assertSuperset(lifeline.getNamespace() == interaction);
	}

	public void testRepresents() {
		Lifeline lifeline = UML.createLifeline();
		assertValid(lifeline);

		Port port = UML.createPort();
		assertValid(port);
		lifeline.setRepresents(port);

		ExtensionEnd extensionEnd = UML.createExtensionEnd();
		assertValid(extensionEnd);
		lifeline.setRepresents(extensionEnd);

		Lifeline lifeline2 = UML.createLifeline();
		assertValid(lifeline2);

		Property property = UML.createProperty();
		assertValid(property);
		lifeline2.setRepresents(property);

		Parameter parameter = UML.createParameter();
		assertValid(parameter);
		lifeline2.setRepresents(parameter);

		Lifeline lifeline3 = UML.createLifeline();
		assertValid(lifeline3);

		Variable variable = UML.createVariable();
		assertValid(variable);
		lifeline3.setRepresents(variable);
	}

	public void testSelector() {
		Lifeline lifeline = UML.createLifeline();
		assertValid(lifeline);

		LiteralBoolean literalBoolean = UML.createLiteralBoolean();
		assertValid(literalBoolean);
		lifeline.setSelector(literalBoolean);
		assertSuperset(lifeline.getOwnedElements().contains(literalBoolean));

		Interval interval = UML.createInterval();
		assertValid(interval);
		lifeline.setSelector(interval);
		assertSuperset(lifeline.getOwnedElements().contains(interval));

		Lifeline lifeline2 = UML.createLifeline();
		assertValid(lifeline2);

		OpaqueExpression opaqueExpression = UML.createOpaqueExpression();
		assertValid(opaqueExpression);
		lifeline2.setSelector(opaqueExpression);
		assertSuperset(lifeline2.getOwnedElements().contains(opaqueExpression));

		Expression expression = UML.createExpression();
		assertValid(expression);
		lifeline2.setSelector(expression);
		assertSuperset(lifeline2.getOwnedElements().contains(expression));

		Lifeline lifeline3 = UML.createLifeline();
		assertValid(lifeline3);

		LiteralReal literalReal = UML.createLiteralReal();
		assertValid(literalReal);
		lifeline3.setSelector(literalReal);
		assertSuperset(lifeline3.getOwnedElements().contains(literalReal));

		LiteralString literalString = UML.createLiteralString();
		assertValid(literalString);
		lifeline3.setSelector(literalString);
		assertSuperset(lifeline3.getOwnedElements().contains(literalString));

		Lifeline lifeline4 = UML.createLifeline();
		assertValid(lifeline4);

		LiteralNull literalNull = UML.createLiteralNull();
		assertValid(literalNull);
		lifeline4.setSelector(literalNull);
		assertSuperset(lifeline4.getOwnedElements().contains(literalNull));

		Duration duration = UML.createDuration();
		assertValid(duration);
		lifeline4.setSelector(duration);
		assertSuperset(lifeline4.getOwnedElements().contains(duration));

		Lifeline lifeline5 = UML.createLifeline();
		assertValid(lifeline5);

		LiteralInteger literalInteger = UML.createLiteralInteger();
		assertValid(literalInteger);
		lifeline5.setSelector(literalInteger);
		assertSuperset(lifeline5.getOwnedElements().contains(literalInteger));

		DurationInterval durationInterval = UML.createDurationInterval();
		assertValid(durationInterval);
		lifeline5.setSelector(durationInterval);
		assertSuperset(lifeline5.getOwnedElements().contains(durationInterval));

		Lifeline lifeline6 = UML.createLifeline();
		assertValid(lifeline6);

		StringExpression stringExpression = UML.createStringExpression();
		assertValid(stringExpression);
		lifeline6.setSelector(stringExpression);
		assertSuperset(lifeline6.getOwnedElements().contains(stringExpression));

		LiteralUnlimitedNatural literalUnlimitedNatural = UML
			.createLiteralUnlimitedNatural();
		assertValid(literalUnlimitedNatural);
		lifeline6.setSelector(literalUnlimitedNatural);
		assertSuperset(
			lifeline6.getOwnedElements().contains(literalUnlimitedNatural));

		Lifeline lifeline7 = UML.createLifeline();
		assertValid(lifeline7);

		TimeInterval timeInterval = UML.createTimeInterval();
		assertValid(timeInterval);
		lifeline7.setSelector(timeInterval);
		assertSuperset(lifeline7.getOwnedElements().contains(timeInterval));

		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);
		lifeline7.setSelector(timeExpression);
		assertSuperset(lifeline7.getOwnedElements().contains(timeExpression));

		Lifeline lifeline8 = UML.createLifeline();
		assertValid(lifeline8);

		InstanceValue instanceValue = UML.createInstanceValue();
		assertValid(instanceValue);
		lifeline8.setSelector(instanceValue);
		assertSuperset(lifeline8.getOwnedElements().contains(instanceValue));
	}

	public void testCoveredBy() {
		Lifeline lifeline = UML.createLifeline();
		assertValid(lifeline);

		CombinedFragment combinedFragment = UML.createCombinedFragment();
		assertValid(combinedFragment);
		lifeline.getCoveredBys().add(combinedFragment);

		StateInvariant stateInvariant = UML.createStateInvariant();
		assertValid(stateInvariant);
		lifeline.getCoveredBys().add(stateInvariant);

		OccurrenceSpecification occurrenceSpecification = UML
			.createOccurrenceSpecification();
		assertValid(occurrenceSpecification);
		lifeline.getCoveredBys().add(occurrenceSpecification);

		InteractionUse interactionUse = UML.createInteractionUse();
		assertValid(interactionUse);
		lifeline.getCoveredBys().add(interactionUse);

		BehaviorExecutionSpecification behaviorExecutionSpecification = UML
			.createBehaviorExecutionSpecification();
		assertValid(behaviorExecutionSpecification);
		lifeline.getCoveredBys().add(behaviorExecutionSpecification);

		ExecutionOccurrenceSpecification executionOccurrenceSpecification = UML
			.createExecutionOccurrenceSpecification();
		assertValid(executionOccurrenceSpecification);
		lifeline.getCoveredBys().add(executionOccurrenceSpecification);

		DestructionOccurrenceSpecification destructionOccurrenceSpecification = UML
			.createDestructionOccurrenceSpecification();
		assertValid(destructionOccurrenceSpecification);
		lifeline.getCoveredBys().add(destructionOccurrenceSpecification);

		InteractionOperand interactionOperand = UML.createInteractionOperand();
		assertValid(interactionOperand);
		lifeline.getCoveredBys().add(interactionOperand);

		MessageOccurrenceSpecification messageOccurrenceSpecification = UML
			.createMessageOccurrenceSpecification();
		assertValid(messageOccurrenceSpecification);
		lifeline.getCoveredBys().add(messageOccurrenceSpecification);

		Interaction interaction = UML.createInteraction();
		assertValid(interaction);
		lifeline.getCoveredBys().add(interaction);

		PartDecomposition partDecomposition = UML.createPartDecomposition();
		assertValid(partDecomposition);
		lifeline.getCoveredBys().add(partDecomposition);

		Continuation continuation = UML.createContinuation();
		assertValid(continuation);
		lifeline.getCoveredBys().add(continuation);

		ConsiderIgnoreFragment considerIgnoreFragment = UML
			.createConsiderIgnoreFragment();
		assertValid(considerIgnoreFragment);
		lifeline.getCoveredBys().add(considerIgnoreFragment);

		ActionExecutionSpecification actionExecutionSpecification = UML
			.createActionExecutionSpecification();
		assertValid(actionExecutionSpecification);
		lifeline.getCoveredBys().add(actionExecutionSpecification);
	}

}