/*
 * 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.DataType;
import org.eclipse.uml2.uml.Dependency;
import org.eclipse.uml2.uml.DeploymentSpecification;
import org.eclipse.uml2.uml.Device;
import org.eclipse.uml2.uml.Duration;
import org.eclipse.uml2.uml.DurationInterval;
import org.eclipse.uml2.uml.DurationObservation;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.Enumeration;
import org.eclipse.uml2.uml.ExecutionEnvironment;
import org.eclipse.uml2.uml.Expression;
import org.eclipse.uml2.uml.Extension;
import org.eclipse.uml2.uml.FunctionBehavior;
import org.eclipse.uml2.uml.InformationItem;
import org.eclipse.uml2.uml.InstanceValue;
import org.eclipse.uml2.uml.Interaction;
import org.eclipse.uml2.uml.Interface;
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.Node;
import org.eclipse.uml2.uml.OpaqueBehavior;
import org.eclipse.uml2.uml.OpaqueExpression;
import org.eclipse.uml2.uml.PrimitiveType;
import org.eclipse.uml2.uml.ProtocolStateMachine;
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.TimeExpression;
import org.eclipse.uml2.uml.TimeInterval;
import org.eclipse.uml2.uml.TimeObservation;
import org.eclipse.uml2.uml.UseCase;

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

	public void testEAnnotations() {
		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);

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

	public void testOwnedComment() {
		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);

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

	public void testOwnedElement() {
		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);
		EList<Element> elements = timeExpression.getOwnedElements();
		EList<Element> elements2 = timeExpression.getOwnedElements();
		assertSame(elements, elements2);
	}

	public void testClientDependency() {
		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);
		EList<Dependency> dependencys = timeExpression.getClientDependencies();
		EList<Dependency> dependencys2 = timeExpression.getClientDependencies();
		assertSame(dependencys, dependencys2);
	}

	public void testNameExpression() {
		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);

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

	public void testOwningTemplateParameter() {
		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);

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

	public void testTemplateParameter() {
		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);

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

	public void testType() {
		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);

		FunctionBehavior functionBehavior = UML.createFunctionBehavior();
		assertValid(functionBehavior);
		timeExpression.setType(functionBehavior);

		Activity activity = UML.createActivity();
		assertValid(activity);
		timeExpression.setType(activity);

		TimeExpression timeExpression2 = UML.createTimeExpression();
		assertValid(timeExpression2);

		Interface interface_ = UML.createInterface();
		assertValid(interface_);
		timeExpression2.setType(interface_);

		InformationItem informationItem = UML.createInformationItem();
		assertValid(informationItem);
		timeExpression2.setType(informationItem);

		TimeExpression timeExpression3 = UML.createTimeExpression();
		assertValid(timeExpression3);

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

		ExecutionEnvironment executionEnvironment = UML
			.createExecutionEnvironment();
		assertValid(executionEnvironment);
		timeExpression3.setType(executionEnvironment);

		TimeExpression timeExpression4 = UML.createTimeExpression();
		assertValid(timeExpression4);

		Component component = UML.createComponent();
		assertValid(component);
		timeExpression4.setType(component);

		Interaction interaction = UML.createInteraction();
		assertValid(interaction);
		timeExpression4.setType(interaction);

		TimeExpression timeExpression5 = UML.createTimeExpression();
		assertValid(timeExpression5);

		DeploymentSpecification deploymentSpecification = UML
			.createDeploymentSpecification();
		assertValid(deploymentSpecification);
		timeExpression5.setType(deploymentSpecification);

		OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior();
		assertValid(opaqueBehavior);
		timeExpression5.setType(opaqueBehavior);

		TimeExpression timeExpression6 = UML.createTimeExpression();
		assertValid(timeExpression6);

		Association association = UML.createAssociation();
		assertValid(association);
		timeExpression6.setType(association);

		DataType dataType = UML.createDataType();
		assertValid(dataType);
		timeExpression6.setType(dataType);

		TimeExpression timeExpression7 = UML.createTimeExpression();
		assertValid(timeExpression7);

		Device device = UML.createDevice();
		assertValid(device);
		timeExpression7.setType(device);

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

		TimeExpression timeExpression8 = UML.createTimeExpression();
		assertValid(timeExpression8);

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

		org.eclipse.uml2.uml.Class class_ = UML.createClass();
		assertValid(class_);
		timeExpression8.setType(class_);

		TimeExpression timeExpression9 = UML.createTimeExpression();
		assertValid(timeExpression9);

		Enumeration enumeration = UML.createEnumeration();
		assertValid(enumeration);
		timeExpression9.setType(enumeration);

		PrimitiveType primitiveType = UML.createPrimitiveType();
		assertValid(primitiveType);
		timeExpression9.setType(primitiveType);

		TimeExpression timeExpression10 = UML.createTimeExpression();
		assertValid(timeExpression10);

		Actor actor = UML.createActor();
		assertValid(actor);
		timeExpression10.setType(actor);

		ProtocolStateMachine protocolStateMachine = UML
			.createProtocolStateMachine();
		assertValid(protocolStateMachine);
		timeExpression10.setType(protocolStateMachine);

		TimeExpression timeExpression11 = UML.createTimeExpression();
		assertValid(timeExpression11);

		UseCase useCase = UML.createUseCase();
		assertValid(useCase);
		timeExpression11.setType(useCase);

		Signal signal = UML.createSignal();
		assertValid(signal);
		timeExpression11.setType(signal);

		TimeExpression timeExpression12 = UML.createTimeExpression();
		assertValid(timeExpression12);

		Node node = UML.createNode();
		assertValid(node);
		timeExpression12.setType(node);

		Stereotype stereotype = UML.createStereotype();
		assertValid(stereotype);
		timeExpression12.setType(stereotype);

		TimeExpression timeExpression13 = UML.createTimeExpression();
		assertValid(timeExpression13);

		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		timeExpression13.setType(stateMachine);

		Artifact artifact = UML.createArtifact();
		assertValid(artifact);
		timeExpression13.setType(artifact);

		TimeExpression timeExpression14 = UML.createTimeExpression();
		assertValid(timeExpression14);

		Collaboration collaboration = UML.createCollaboration();
		assertValid(collaboration);
		timeExpression14.setType(collaboration);
	}

	public void testExpr() {
		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);

		LiteralBoolean literalBoolean = UML.createLiteralBoolean();
		assertValid(literalBoolean);
		timeExpression.setExpr(literalBoolean);
		assertSuperset(
			timeExpression.getOwnedElements().contains(literalBoolean));

		Interval interval = UML.createInterval();
		assertValid(interval);
		timeExpression.setExpr(interval);
		assertSuperset(timeExpression.getOwnedElements().contains(interval));

		TimeExpression timeExpression2 = UML.createTimeExpression();
		assertValid(timeExpression2);

		OpaqueExpression opaqueExpression = UML.createOpaqueExpression();
		assertValid(opaqueExpression);
		timeExpression2.setExpr(opaqueExpression);
		assertSuperset(
			timeExpression2.getOwnedElements().contains(opaqueExpression));

		Expression expression = UML.createExpression();
		assertValid(expression);
		timeExpression2.setExpr(expression);
		assertSuperset(timeExpression2.getOwnedElements().contains(expression));

		TimeExpression timeExpression3 = UML.createTimeExpression();
		assertValid(timeExpression3);

		LiteralReal literalReal = UML.createLiteralReal();
		assertValid(literalReal);
		timeExpression3.setExpr(literalReal);
		assertSuperset(
			timeExpression3.getOwnedElements().contains(literalReal));

		LiteralString literalString = UML.createLiteralString();
		assertValid(literalString);
		timeExpression3.setExpr(literalString);
		assertSuperset(
			timeExpression3.getOwnedElements().contains(literalString));

		TimeExpression timeExpression4 = UML.createTimeExpression();
		assertValid(timeExpression4);

		LiteralNull literalNull = UML.createLiteralNull();
		assertValid(literalNull);
		timeExpression4.setExpr(literalNull);
		assertSuperset(
			timeExpression4.getOwnedElements().contains(literalNull));

		Duration duration = UML.createDuration();
		assertValid(duration);
		timeExpression4.setExpr(duration);
		assertSuperset(timeExpression4.getOwnedElements().contains(duration));

		TimeExpression timeExpression5 = UML.createTimeExpression();
		assertValid(timeExpression5);

		LiteralInteger literalInteger = UML.createLiteralInteger();
		assertValid(literalInteger);
		timeExpression5.setExpr(literalInteger);
		assertSuperset(
			timeExpression5.getOwnedElements().contains(literalInteger));

		DurationInterval durationInterval = UML.createDurationInterval();
		assertValid(durationInterval);
		timeExpression5.setExpr(durationInterval);
		assertSuperset(
			timeExpression5.getOwnedElements().contains(durationInterval));

		TimeExpression timeExpression6 = UML.createTimeExpression();
		assertValid(timeExpression6);

		StringExpression stringExpression = UML.createStringExpression();
		assertValid(stringExpression);
		timeExpression6.setExpr(stringExpression);
		assertSuperset(
			timeExpression6.getOwnedElements().contains(stringExpression));

		LiteralUnlimitedNatural literalUnlimitedNatural = UML
			.createLiteralUnlimitedNatural();
		assertValid(literalUnlimitedNatural);
		timeExpression6.setExpr(literalUnlimitedNatural);
		assertSuperset(timeExpression6.getOwnedElements()
			.contains(literalUnlimitedNatural));

		TimeExpression timeExpression7 = UML.createTimeExpression();
		assertValid(timeExpression7);

		TimeInterval timeInterval = UML.createTimeInterval();
		assertValid(timeInterval);
		timeExpression7.setExpr(timeInterval);
		assertSuperset(
			timeExpression7.getOwnedElements().contains(timeInterval));

		TimeExpression timeExpression8 = UML.createTimeExpression();
		assertValid(timeExpression8);
		timeExpression7.setExpr(timeExpression8);
		assertSuperset(
			timeExpression7.getOwnedElements().contains(timeExpression8));

		TimeExpression timeExpression9 = UML.createTimeExpression();
		assertValid(timeExpression9);

		InstanceValue instanceValue = UML.createInstanceValue();
		assertValid(instanceValue);
		timeExpression9.setExpr(instanceValue);
		assertSuperset(
			timeExpression9.getOwnedElements().contains(instanceValue));
	}

	public void testObservation() {
		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);

		TimeObservation timeObservation = UML.createTimeObservation();
		assertValid(timeObservation);
		timeExpression.getObservations().add(timeObservation);

		DurationObservation durationObservation = UML
			.createDurationObservation();
		assertValid(durationObservation);
		timeExpression.getObservations().add(durationObservation);
	}

}