/*
 * 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.Classifier;
import org.eclipse.uml2.uml.Comment;
import org.eclipse.uml2.uml.ConnectionPointReference;
import org.eclipse.uml2.uml.Constraint;
import org.eclipse.uml2.uml.Dependency;
import org.eclipse.uml2.uml.DurationConstraint;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.ElementImport;
import org.eclipse.uml2.uml.FinalState;
import org.eclipse.uml2.uml.InteractionConstraint;
import org.eclipse.uml2.uml.IntervalConstraint;
import org.eclipse.uml2.uml.NamedElement;
import org.eclipse.uml2.uml.PackageImport;
import org.eclipse.uml2.uml.PackageableElement;
import org.eclipse.uml2.uml.ProtocolStateMachine;
import org.eclipse.uml2.uml.ProtocolTransition;
import org.eclipse.uml2.uml.Pseudostate;
import org.eclipse.uml2.uml.RedefinableElement;
import org.eclipse.uml2.uml.Region;
import org.eclipse.uml2.uml.State;
import org.eclipse.uml2.uml.StateMachine;
import org.eclipse.uml2.uml.StringExpression;
import org.eclipse.uml2.uml.TimeConstraint;
import org.eclipse.uml2.uml.Transition;
import org.eclipse.uml2.uml.Trigger;

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

	public void testEAnnotations() {
		Transition transition = UML.createTransition();
		assertValid(transition);

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

	public void testOwnedComment() {
		Transition transition = UML.createTransition();
		assertValid(transition);

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

	public void testOwnedElement() {
		Transition transition = UML.createTransition();
		assertValid(transition);
		EList<Element> elements = transition.getOwnedElements();
		EList<Element> elements2 = transition.getOwnedElements();
		assertSame(elements, elements2);
	}

	public void testClientDependency() {
		Transition transition = UML.createTransition();
		assertValid(transition);
		EList<Dependency> dependencys = transition.getClientDependencies();
		EList<Dependency> dependencys2 = transition.getClientDependencies();
		assertSame(dependencys, dependencys2);
	}

	public void testNameExpression() {
		Transition transition = UML.createTransition();
		assertValid(transition);

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

	public void testOwnedRule() {
		Transition transition = UML.createTransition();
		assertValid(transition);

		IntervalConstraint intervalConstraint = UML.createIntervalConstraint();
		assertValid(intervalConstraint);
		transition.getOwnedRules().add(intervalConstraint);
		assertSuperset(
			transition.getOwnedMembers().contains(intervalConstraint));

		TimeConstraint timeConstraint = UML.createTimeConstraint();
		assertValid(timeConstraint);
		transition.getOwnedRules().add(timeConstraint);
		assertSuperset(transition.getOwnedMembers().contains(timeConstraint));

		InteractionConstraint interactionConstraint = UML
			.createInteractionConstraint();
		assertValid(interactionConstraint);
		transition.getOwnedRules().add(interactionConstraint);
		assertSuperset(
			transition.getOwnedMembers().contains(interactionConstraint));

		Constraint constraint = UML.createConstraint();
		assertValid(constraint);
		transition.getOwnedRules().add(constraint);
		assertSuperset(transition.getOwnedMembers().contains(constraint));

		DurationConstraint durationConstraint = UML.createDurationConstraint();
		assertValid(durationConstraint);
		transition.getOwnedRules().add(durationConstraint);
		assertSuperset(
			transition.getOwnedMembers().contains(durationConstraint));
	}

	public void testElementImport() {
		Transition transition = UML.createTransition();
		assertValid(transition);

		ElementImport elementImport = UML.createElementImport();
		assertValid(elementImport);
		transition.getElementImports().add(elementImport);
		assertSuperset(transition.getOwnedElements().contains(elementImport));
	}

	public void testPackageImport() {
		Transition transition = UML.createTransition();
		assertValid(transition);

		PackageImport packageImport = UML.createPackageImport();
		assertValid(packageImport);
		transition.getPackageImports().add(packageImport);
		assertSuperset(transition.getOwnedElements().contains(packageImport));
	}

	public void testOwnedMember() {
		Transition transition = UML.createTransition();
		assertValid(transition);
		EList<NamedElement> namedElements = transition.getOwnedMembers();
		EList<NamedElement> namedElements2 = transition.getOwnedMembers();
		assertSame(namedElements, namedElements2);
	}

	public void testImportedMember() {
		Transition transition = UML.createTransition();
		assertValid(transition);
		EList<PackageableElement> packageableElements = transition
			.getImportedMembers();
		EList<PackageableElement> packageableElements2 = transition
			.getImportedMembers();
		assertSame(packageableElements, packageableElements2);
	}

	public void testMember() {
		Transition transition = UML.createTransition();
		assertValid(transition);
		EList<NamedElement> namedElements = transition.getMembers();
		EList<NamedElement> namedElements2 = transition.getMembers();
		assertSame(namedElements, namedElements2);
	}

	public void testRedefinedElement() {
		Transition transition = UML.createTransition();
		assertValid(transition);
		EList<RedefinableElement> redefinableElements = transition
			.getRedefinedElements();
		EList<RedefinableElement> redefinableElements2 = transition
			.getRedefinedElements();
		assertSame(redefinableElements, redefinableElements2);
	}

	public void testRedefinitionContext() {
		Transition transition = UML.createTransition();
		assertValid(transition);
		EList<Classifier> classifiers = transition.getRedefinitionContexts();
		EList<Classifier> classifiers2 = transition.getRedefinitionContexts();
		assertSame(classifiers, classifiers2);
	}

	public void testEffect() {
		Transition transition = UML.createTransition();
		assertValid(transition);

		ProtocolStateMachine protocolStateMachine = UML
			.createProtocolStateMachine();
		assertValid(protocolStateMachine);
		transition.setEffect(protocolStateMachine);
		assertSuperset(
			transition.getOwnedElements().contains(protocolStateMachine));

		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		transition.setEffect(stateMachine);
		assertSuperset(transition.getOwnedElements().contains(stateMachine));
	}

	public void testGuard() {
		Transition transition = UML.createTransition();
		assertValid(transition);

		IntervalConstraint intervalConstraint = UML.createIntervalConstraint();
		assertValid(intervalConstraint);
		transition.setGuard(intervalConstraint);
		assertSuperset(transition.getOwnedRules().contains(intervalConstraint));

		TimeConstraint timeConstraint = UML.createTimeConstraint();
		assertValid(timeConstraint);
		transition.setGuard(timeConstraint);
		assertSuperset(transition.getOwnedRules().contains(timeConstraint));

		Transition transition2 = UML.createTransition();
		assertValid(transition2);

		InteractionConstraint interactionConstraint = UML
			.createInteractionConstraint();
		assertValid(interactionConstraint);
		transition2.setGuard(interactionConstraint);
		assertSuperset(
			transition2.getOwnedRules().contains(interactionConstraint));

		Constraint constraint = UML.createConstraint();
		assertValid(constraint);
		transition2.setGuard(constraint);
		assertSuperset(transition2.getOwnedRules().contains(constraint));

		Transition transition3 = UML.createTransition();
		assertValid(transition3);

		DurationConstraint durationConstraint = UML.createDurationConstraint();
		assertValid(durationConstraint);
		transition3.setGuard(durationConstraint);
		assertSuperset(
			transition3.getOwnedRules().contains(durationConstraint));
	}

	public void testRedefinedTransition() {
		Transition transition = UML.createTransition();
		assertValid(transition);

		Transition transition2 = UML.createTransition();
		assertValid(transition2);
		transition.setRedefinedTransition(transition2);
		assertSuperset(transition.getRedefinedElements().contains(transition2));

		ProtocolTransition protocolTransition = UML.createProtocolTransition();
		assertValid(protocolTransition);
		transition.setRedefinedTransition(protocolTransition);
		assertSuperset(
			transition.getRedefinedElements().contains(protocolTransition));
	}

	public void testSource() {
		Transition transition = UML.createTransition();
		assertValid(transition);

		Pseudostate pseudostate = UML.createPseudostate();
		assertValid(pseudostate);
		transition.setSource(pseudostate);

		ConnectionPointReference connectionPointReference = UML
			.createConnectionPointReference();
		assertValid(connectionPointReference);
		transition.setSource(connectionPointReference);

		Transition transition2 = UML.createTransition();
		assertValid(transition2);

		FinalState finalState = UML.createFinalState();
		assertValid(finalState);
		transition2.setSource(finalState);

		State state = UML.createState();
		assertValid(state);
		transition2.setSource(state);
	}

	public void testTarget() {
		Transition transition = UML.createTransition();
		assertValid(transition);

		Pseudostate pseudostate = UML.createPseudostate();
		assertValid(pseudostate);
		transition.setTarget(pseudostate);

		ConnectionPointReference connectionPointReference = UML
			.createConnectionPointReference();
		assertValid(connectionPointReference);
		transition.setTarget(connectionPointReference);

		Transition transition2 = UML.createTransition();
		assertValid(transition2);

		FinalState finalState = UML.createFinalState();
		assertValid(finalState);
		transition2.setTarget(finalState);

		State state = UML.createState();
		assertValid(state);
		transition2.setTarget(state);
	}

	public void testTrigger() {
		Transition transition = UML.createTransition();
		assertValid(transition);

		Trigger trigger = UML.createTrigger();
		assertValid(trigger);
		transition.getTriggers().add(trigger);
		assertSuperset(transition.getOwnedElements().contains(trigger));
	}

	public void testContainer() {
		Transition transition = UML.createTransition();
		assertValid(transition);

		Region region = UML.createRegion();
		assertValid(region);
		transition.setContainer(region);
		assertSuperset(transition.getNamespace() == region);
	}

}