cdo/tests/uml/org.eclipse.uml2.uml.cdo.tests/src/org/eclipse/uml2/uml/cdo/tests/compliance/StateMachineTest.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.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.Classifier;
import org.eclipse.uml2.uml.ClassifierTemplateParameter;
import org.eclipse.uml2.uml.Collaboration;
import org.eclipse.uml2.uml.CollaborationUse;
import org.eclipse.uml2.uml.Comment;
import org.eclipse.uml2.uml.CommunicationPath;
import org.eclipse.uml2.uml.Component;
import org.eclipse.uml2.uml.ConnectableElement;
import org.eclipse.uml2.uml.Connector;
import org.eclipse.uml2.uml.Constraint;
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.DurationConstraint;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.ElementImport;
import org.eclipse.uml2.uml.Enumeration;
import org.eclipse.uml2.uml.ExecutionEnvironment;
import org.eclipse.uml2.uml.Extension;
import org.eclipse.uml2.uml.ExtensionEnd;
import org.eclipse.uml2.uml.Feature;
import org.eclipse.uml2.uml.FinalState;
import org.eclipse.uml2.uml.FunctionBehavior;
import org.eclipse.uml2.uml.Generalization;
import org.eclipse.uml2.uml.GeneralizationSet;
import org.eclipse.uml2.uml.InformationItem;
import org.eclipse.uml2.uml.Interaction;
import org.eclipse.uml2.uml.InteractionConstraint;
import org.eclipse.uml2.uml.Interface;
import org.eclipse.uml2.uml.InterfaceRealization;
import org.eclipse.uml2.uml.IntervalConstraint;
import org.eclipse.uml2.uml.NamedElement;
import org.eclipse.uml2.uml.Node;
import org.eclipse.uml2.uml.OpaqueBehavior;
import org.eclipse.uml2.uml.Operation;
import org.eclipse.uml2.uml.PackageImport;
import org.eclipse.uml2.uml.PackageableElement;
import org.eclipse.uml2.uml.Parameter;
import org.eclipse.uml2.uml.ParameterSet;
import org.eclipse.uml2.uml.Port;
import org.eclipse.uml2.uml.PrimitiveType;
import org.eclipse.uml2.uml.Property;
import org.eclipse.uml2.uml.ProtocolStateMachine;
import org.eclipse.uml2.uml.Pseudostate;
import org.eclipse.uml2.uml.Reception;
import org.eclipse.uml2.uml.RedefinableElement;
import org.eclipse.uml2.uml.RedefinableTemplateSignature;
import org.eclipse.uml2.uml.Region;
import org.eclipse.uml2.uml.Signal;
import org.eclipse.uml2.uml.State;
import org.eclipse.uml2.uml.StateMachine;
import org.eclipse.uml2.uml.Stereotype;
import org.eclipse.uml2.uml.StringExpression;
import org.eclipse.uml2.uml.Substitution;
import org.eclipse.uml2.uml.TemplateBinding;
import org.eclipse.uml2.uml.TimeConstraint;
import org.eclipse.uml2.uml.UseCase;

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

	public void testEAnnotations() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

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

	public void testOwnedComment() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

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

	public void testOwnedElement() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<Element> elements = stateMachine.getOwnedElements();
		EList<Element> elements2 = stateMachine.getOwnedElements();
		assertSame(elements, elements2);
	}

	public void testClientDependency() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<Dependency> dependencys = stateMachine.getClientDependencies();
		EList<Dependency> dependencys2 = stateMachine.getClientDependencies();
		assertSame(dependencys, dependencys2);
	}

	public void testNameExpression() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

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

	public void testOwnedRule() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

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

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

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

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

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

	public void testElementImport() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

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

	public void testPackageImport() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

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

	public void testOwnedMember() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<NamedElement> namedElements = stateMachine.getOwnedMembers();
		EList<NamedElement> namedElements2 = stateMachine.getOwnedMembers();
		assertSame(namedElements, namedElements2);
	}

	public void testImportedMember() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<PackageableElement> packageableElements = stateMachine
			.getImportedMembers();
		EList<PackageableElement> packageableElements2 = stateMachine
			.getImportedMembers();
		assertSame(packageableElements, packageableElements2);
	}

	public void testMember() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<NamedElement> namedElements = stateMachine.getMembers();
		EList<NamedElement> namedElements2 = stateMachine.getMembers();
		assertSame(namedElements, namedElements2);
	}

	public void testRedefinedElement() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<RedefinableElement> redefinableElements = stateMachine
			.getRedefinedElements();
		EList<RedefinableElement> redefinableElements2 = stateMachine
			.getRedefinedElements();
		assertSame(redefinableElements, redefinableElements2);
	}

	public void testRedefinitionContext() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<Classifier> classifiers = stateMachine.getRedefinitionContexts();
		EList<Classifier> classifiers2 = stateMachine.getRedefinitionContexts();
		assertSame(classifiers, classifiers2);
	}

	public void testOwningTemplateParameter() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		ClassifierTemplateParameter classifierTemplateParameter = UML
			.createClassifierTemplateParameter();
		assertValid(classifierTemplateParameter);
		stateMachine.setOwningTemplateParameter(classifierTemplateParameter);
		assertSuperset(stateMachine.getOwner() == classifierTemplateParameter);
		assertSuperset(
			stateMachine.getTemplateParameter() == classifierTemplateParameter);
	}

	public void testTemplateParameter() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		ClassifierTemplateParameter classifierTemplateParameter = UML
			.createClassifierTemplateParameter();
		assertValid(classifierTemplateParameter);
		stateMachine.setTemplateParameter(classifierTemplateParameter);
	}

	public void testTemplateBinding() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		TemplateBinding templateBinding = UML.createTemplateBinding();
		assertValid(templateBinding);
		stateMachine.getTemplateBindings().add(templateBinding);
		assertSuperset(
			stateMachine.getOwnedElements().contains(templateBinding));
	}

	public void testOwnedTemplateSignature() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);
		stateMachine.setOwnedTemplateSignature(redefinableTemplateSignature);
		assertSuperset(stateMachine.getOwnedElements()
			.contains(redefinableTemplateSignature));
	}

	public void testFeature() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<Feature> features = stateMachine.getFeatures();
		EList<Feature> features2 = stateMachine.getFeatures();
		assertSame(features, features2);
	}

	public void testAttribute() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<Property> propertys = stateMachine.getAttributes();
		EList<Property> propertys2 = stateMachine.getAttributes();
		assertSame(propertys, propertys2);
	}

	public void testCollaborationUse() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		CollaborationUse collaborationUse = UML.createCollaborationUse();
		assertValid(collaborationUse);
		stateMachine.getCollaborationUses().add(collaborationUse);
		assertSuperset(
			stateMachine.getOwnedElements().contains(collaborationUse));
	}

	public void testGeneral() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<Classifier> classifiers = stateMachine.getGenerals();
		EList<Classifier> classifiers2 = stateMachine.getGenerals();
		assertSame(classifiers, classifiers2);
	}

	public void testGeneralization() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		Generalization generalization = UML.createGeneralization();
		assertValid(generalization);
		stateMachine.getGeneralizations().add(generalization);
		assertSuperset(
			stateMachine.getOwnedElements().contains(generalization));
	}

	public void testPowertypeExtent() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		GeneralizationSet generalizationSet = UML.createGeneralizationSet();
		assertValid(generalizationSet);
		stateMachine.getPowertypeExtents().add(generalizationSet);
	}

	public void testInheritedMember() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<NamedElement> namedElements = stateMachine.getInheritedMembers();
		EList<NamedElement> namedElements2 = stateMachine.getInheritedMembers();
		assertSame(namedElements, namedElements2);
	}

	public void testOwnedUseCase() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		UseCase useCase = UML.createUseCase();
		assertValid(useCase);
		stateMachine.getOwnedUseCases().add(useCase);
		assertSuperset(stateMachine.getOwnedMembers().contains(useCase));
	}

	public void testUseCase() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		UseCase useCase = UML.createUseCase();
		assertValid(useCase);
		stateMachine.getUseCases().add(useCase);
	}

	public void testRedefinedClassifier() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		FunctionBehavior functionBehavior = UML.createFunctionBehavior();
		assertValid(functionBehavior);
		stateMachine.getRedefinedClassifiers().add(functionBehavior);
		assertSuperset(
			stateMachine.getRedefinedElements().contains(functionBehavior));

		Activity activity = UML.createActivity();
		assertValid(activity);
		stateMachine.getRedefinedClassifiers().add(activity);
		assertSuperset(stateMachine.getRedefinedElements().contains(activity));

		Interface interface_ = UML.createInterface();
		assertValid(interface_);
		stateMachine.getRedefinedClassifiers().add(interface_);
		assertSuperset(
			stateMachine.getRedefinedElements().contains(interface_));

		InformationItem informationItem = UML.createInformationItem();
		assertValid(informationItem);
		stateMachine.getRedefinedClassifiers().add(informationItem);
		assertSuperset(
			stateMachine.getRedefinedElements().contains(informationItem));

		CommunicationPath communicationPath = UML.createCommunicationPath();
		assertValid(communicationPath);
		stateMachine.getRedefinedClassifiers().add(communicationPath);
		assertSuperset(
			stateMachine.getRedefinedElements().contains(communicationPath));

		ExecutionEnvironment executionEnvironment = UML
			.createExecutionEnvironment();
		assertValid(executionEnvironment);
		stateMachine.getRedefinedClassifiers().add(executionEnvironment);
		assertSuperset(
			stateMachine.getRedefinedElements().contains(executionEnvironment));

		Component component = UML.createComponent();
		assertValid(component);
		stateMachine.getRedefinedClassifiers().add(component);
		assertSuperset(stateMachine.getRedefinedElements().contains(component));

		Interaction interaction = UML.createInteraction();
		assertValid(interaction);
		stateMachine.getRedefinedClassifiers().add(interaction);
		assertSuperset(
			stateMachine.getRedefinedElements().contains(interaction));

		DeploymentSpecification deploymentSpecification = UML
			.createDeploymentSpecification();
		assertValid(deploymentSpecification);
		stateMachine.getRedefinedClassifiers().add(deploymentSpecification);
		assertSuperset(stateMachine.getRedefinedElements()
			.contains(deploymentSpecification));

		OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior();
		assertValid(opaqueBehavior);
		stateMachine.getRedefinedClassifiers().add(opaqueBehavior);
		assertSuperset(
			stateMachine.getRedefinedElements().contains(opaqueBehavior));

		Association association = UML.createAssociation();
		assertValid(association);
		stateMachine.getRedefinedClassifiers().add(association);
		assertSuperset(
			stateMachine.getRedefinedElements().contains(association));

		DataType dataType = UML.createDataType();
		assertValid(dataType);
		stateMachine.getRedefinedClassifiers().add(dataType);
		assertSuperset(stateMachine.getRedefinedElements().contains(dataType));

		Device device = UML.createDevice();
		assertValid(device);
		stateMachine.getRedefinedClassifiers().add(device);
		assertSuperset(stateMachine.getRedefinedElements().contains(device));

		Extension extension = UML.createExtension();
		assertValid(extension);
		stateMachine.getRedefinedClassifiers().add(extension);
		assertSuperset(stateMachine.getRedefinedElements().contains(extension));

		AssociationClass associationClass = UML.createAssociationClass();
		assertValid(associationClass);
		stateMachine.getRedefinedClassifiers().add(associationClass);
		assertSuperset(
			stateMachine.getRedefinedElements().contains(associationClass));

		org.eclipse.uml2.uml.Class class_ = UML.createClass();
		assertValid(class_);
		stateMachine.getRedefinedClassifiers().add(class_);
		assertSuperset(stateMachine.getRedefinedElements().contains(class_));

		Enumeration enumeration = UML.createEnumeration();
		assertValid(enumeration);
		stateMachine.getRedefinedClassifiers().add(enumeration);
		assertSuperset(
			stateMachine.getRedefinedElements().contains(enumeration));

		PrimitiveType primitiveType = UML.createPrimitiveType();
		assertValid(primitiveType);
		stateMachine.getRedefinedClassifiers().add(primitiveType);
		assertSuperset(
			stateMachine.getRedefinedElements().contains(primitiveType));

		Actor actor = UML.createActor();
		assertValid(actor);
		stateMachine.getRedefinedClassifiers().add(actor);
		assertSuperset(stateMachine.getRedefinedElements().contains(actor));

		ProtocolStateMachine protocolStateMachine = UML
			.createProtocolStateMachine();
		assertValid(protocolStateMachine);
		stateMachine.getRedefinedClassifiers().add(protocolStateMachine);
		assertSuperset(
			stateMachine.getRedefinedElements().contains(protocolStateMachine));

		UseCase useCase = UML.createUseCase();
		assertValid(useCase);
		stateMachine.getRedefinedClassifiers().add(useCase);
		assertSuperset(stateMachine.getRedefinedElements().contains(useCase));

		Signal signal = UML.createSignal();
		assertValid(signal);
		stateMachine.getRedefinedClassifiers().add(signal);
		assertSuperset(stateMachine.getRedefinedElements().contains(signal));

		Node node = UML.createNode();
		assertValid(node);
		stateMachine.getRedefinedClassifiers().add(node);
		assertSuperset(stateMachine.getRedefinedElements().contains(node));

		Stereotype stereotype = UML.createStereotype();
		assertValid(stereotype);
		stateMachine.getRedefinedClassifiers().add(stereotype);
		assertSuperset(
			stateMachine.getRedefinedElements().contains(stereotype));

		StateMachine stateMachine2 = UML.createStateMachine();
		assertValid(stateMachine2);
		stateMachine.getRedefinedClassifiers().add(stateMachine2);
		assertSuperset(
			stateMachine.getRedefinedElements().contains(stateMachine2));

		Artifact artifact = UML.createArtifact();
		assertValid(artifact);
		stateMachine.getRedefinedClassifiers().add(artifact);
		assertSuperset(stateMachine.getRedefinedElements().contains(artifact));

		Collaboration collaboration = UML.createCollaboration();
		assertValid(collaboration);
		stateMachine.getRedefinedClassifiers().add(collaboration);
		assertSuperset(
			stateMachine.getRedefinedElements().contains(collaboration));
	}

	public void testRepresentation() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		CollaborationUse collaborationUse = UML.createCollaborationUse();
		assertValid(collaborationUse);
		stateMachine.setRepresentation(collaborationUse);
		assertSuperset(
			stateMachine.getCollaborationUses().contains(collaborationUse));
	}

	public void testSubstitution() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		Substitution substitution = UML.createSubstitution();
		assertValid(substitution);
		stateMachine.getSubstitutions().add(substitution);
		assertSuperset(stateMachine.getOwnedElements().contains(substitution));
		assertSuperset(
			stateMachine.getClientDependencies().contains(substitution));
	}

	public void testOwnedAttribute() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		Port port = UML.createPort();
		assertValid(port);
		stateMachine.getOwnedAttributes().add(port);
		assertSuperset(stateMachine.getAttributes().contains(port));
		assertSuperset(stateMachine.getOwnedMembers().contains(port));
		assertSuperset(stateMachine.getRoles().contains(port));

		ExtensionEnd extensionEnd = UML.createExtensionEnd();
		assertValid(extensionEnd);
		stateMachine.getOwnedAttributes().add(extensionEnd);
		assertSuperset(stateMachine.getAttributes().contains(extensionEnd));
		assertSuperset(stateMachine.getOwnedMembers().contains(extensionEnd));
		assertSuperset(stateMachine.getRoles().contains(extensionEnd));

		Property property = UML.createProperty();
		assertValid(property);
		stateMachine.getOwnedAttributes().add(property);
		assertSuperset(stateMachine.getAttributes().contains(property));
		assertSuperset(stateMachine.getOwnedMembers().contains(property));
		assertSuperset(stateMachine.getRoles().contains(property));
	}

	public void testOwnedConnector() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		Connector connector = UML.createConnector();
		assertValid(connector);
		stateMachine.getOwnedConnectors().add(connector);
		assertSuperset(stateMachine.getFeatures().contains(connector));
		assertSuperset(stateMachine.getOwnedMembers().contains(connector));
	}

	public void testPart() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<Property> propertys = stateMachine.getParts();
		EList<Property> propertys2 = stateMachine.getParts();
		assertSame(propertys, propertys2);
	}

	public void testRole() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<ConnectableElement> connectableElements = stateMachine.getRoles();
		EList<ConnectableElement> connectableElements2 = stateMachine
			.getRoles();
		assertSame(connectableElements, connectableElements2);
	}

	public void testOwnedPort() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<Port> ports = stateMachine.getOwnedPorts();
		EList<Port> ports2 = stateMachine.getOwnedPorts();
		assertSame(ports, ports2);
	}

	public void testClassifierBehavior() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		ProtocolStateMachine protocolStateMachine = UML
			.createProtocolStateMachine();
		assertValid(protocolStateMachine);
		stateMachine.setClassifierBehavior(protocolStateMachine);
		assertSuperset(
			stateMachine.getOwnedBehaviors().contains(protocolStateMachine));

		StateMachine stateMachine2 = UML.createStateMachine();
		assertValid(stateMachine2);
		stateMachine.setClassifierBehavior(stateMachine2);
		assertSuperset(
			stateMachine.getOwnedBehaviors().contains(stateMachine2));
	}

	public void testInterfaceRealization() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);
		stateMachine.getInterfaceRealizations().add(interfaceRealization);
		assertSuperset(
			stateMachine.getOwnedElements().contains(interfaceRealization));
		assertSuperset(stateMachine.getClientDependencies()
			.contains(interfaceRealization));
	}

	public void testOwnedBehavior() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		ProtocolStateMachine protocolStateMachine = UML
			.createProtocolStateMachine();
		assertValid(protocolStateMachine);
		stateMachine.getOwnedBehaviors().add(protocolStateMachine);
		assertSuperset(
			stateMachine.getOwnedMembers().contains(protocolStateMachine));

		StateMachine stateMachine2 = UML.createStateMachine();
		assertValid(stateMachine2);
		stateMachine.getOwnedBehaviors().add(stateMachine2);
		assertSuperset(stateMachine.getOwnedMembers().contains(stateMachine2));
	}

	public void testOwnedOperation() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		Operation operation = UML.createOperation();
		assertValid(operation);
		stateMachine.getOwnedOperations().add(operation);
		assertSuperset(stateMachine.getFeatures().contains(operation));
		assertSuperset(stateMachine.getOwnedMembers().contains(operation));
	}

	public void testExtension() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<Extension> extensions = stateMachine.getExtensions();
		EList<Extension> extensions2 = stateMachine.getExtensions();
		assertSame(extensions, extensions2);
	}

	public void testNestedClassifier() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		FunctionBehavior functionBehavior = UML.createFunctionBehavior();
		assertValid(functionBehavior);
		stateMachine.getNestedClassifiers().add(functionBehavior);
		assertSuperset(
			stateMachine.getOwnedMembers().contains(functionBehavior));

		Activity activity = UML.createActivity();
		assertValid(activity);
		stateMachine.getNestedClassifiers().add(activity);
		assertSuperset(stateMachine.getOwnedMembers().contains(activity));

		Interface interface_ = UML.createInterface();
		assertValid(interface_);
		stateMachine.getNestedClassifiers().add(interface_);
		assertSuperset(stateMachine.getOwnedMembers().contains(interface_));

		InformationItem informationItem = UML.createInformationItem();
		assertValid(informationItem);
		stateMachine.getNestedClassifiers().add(informationItem);
		assertSuperset(
			stateMachine.getOwnedMembers().contains(informationItem));

		CommunicationPath communicationPath = UML.createCommunicationPath();
		assertValid(communicationPath);
		stateMachine.getNestedClassifiers().add(communicationPath);
		assertSuperset(
			stateMachine.getOwnedMembers().contains(communicationPath));

		ExecutionEnvironment executionEnvironment = UML
			.createExecutionEnvironment();
		assertValid(executionEnvironment);
		stateMachine.getNestedClassifiers().add(executionEnvironment);
		assertSuperset(
			stateMachine.getOwnedMembers().contains(executionEnvironment));

		Component component = UML.createComponent();
		assertValid(component);
		stateMachine.getNestedClassifiers().add(component);
		assertSuperset(stateMachine.getOwnedMembers().contains(component));

		Interaction interaction = UML.createInteraction();
		assertValid(interaction);
		stateMachine.getNestedClassifiers().add(interaction);
		assertSuperset(stateMachine.getOwnedMembers().contains(interaction));

		DeploymentSpecification deploymentSpecification = UML
			.createDeploymentSpecification();
		assertValid(deploymentSpecification);
		stateMachine.getNestedClassifiers().add(deploymentSpecification);
		assertSuperset(
			stateMachine.getOwnedMembers().contains(deploymentSpecification));

		OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior();
		assertValid(opaqueBehavior);
		stateMachine.getNestedClassifiers().add(opaqueBehavior);
		assertSuperset(stateMachine.getOwnedMembers().contains(opaqueBehavior));

		Association association = UML.createAssociation();
		assertValid(association);
		stateMachine.getNestedClassifiers().add(association);
		assertSuperset(stateMachine.getOwnedMembers().contains(association));

		DataType dataType = UML.createDataType();
		assertValid(dataType);
		stateMachine.getNestedClassifiers().add(dataType);
		assertSuperset(stateMachine.getOwnedMembers().contains(dataType));

		Device device = UML.createDevice();
		assertValid(device);
		stateMachine.getNestedClassifiers().add(device);
		assertSuperset(stateMachine.getOwnedMembers().contains(device));

		Extension extension = UML.createExtension();
		assertValid(extension);
		stateMachine.getNestedClassifiers().add(extension);
		assertSuperset(stateMachine.getOwnedMembers().contains(extension));

		AssociationClass associationClass = UML.createAssociationClass();
		assertValid(associationClass);
		stateMachine.getNestedClassifiers().add(associationClass);
		assertSuperset(
			stateMachine.getOwnedMembers().contains(associationClass));

		org.eclipse.uml2.uml.Class class_ = UML.createClass();
		assertValid(class_);
		stateMachine.getNestedClassifiers().add(class_);
		assertSuperset(stateMachine.getOwnedMembers().contains(class_));

		Enumeration enumeration = UML.createEnumeration();
		assertValid(enumeration);
		stateMachine.getNestedClassifiers().add(enumeration);
		assertSuperset(stateMachine.getOwnedMembers().contains(enumeration));

		PrimitiveType primitiveType = UML.createPrimitiveType();
		assertValid(primitiveType);
		stateMachine.getNestedClassifiers().add(primitiveType);
		assertSuperset(stateMachine.getOwnedMembers().contains(primitiveType));

		Actor actor = UML.createActor();
		assertValid(actor);
		stateMachine.getNestedClassifiers().add(actor);
		assertSuperset(stateMachine.getOwnedMembers().contains(actor));

		ProtocolStateMachine protocolStateMachine = UML
			.createProtocolStateMachine();
		assertValid(protocolStateMachine);
		stateMachine.getNestedClassifiers().add(protocolStateMachine);
		assertSuperset(
			stateMachine.getOwnedMembers().contains(protocolStateMachine));

		UseCase useCase = UML.createUseCase();
		assertValid(useCase);
		stateMachine.getNestedClassifiers().add(useCase);
		assertSuperset(stateMachine.getOwnedMembers().contains(useCase));

		Signal signal = UML.createSignal();
		assertValid(signal);
		stateMachine.getNestedClassifiers().add(signal);
		assertSuperset(stateMachine.getOwnedMembers().contains(signal));

		Node node = UML.createNode();
		assertValid(node);
		stateMachine.getNestedClassifiers().add(node);
		assertSuperset(stateMachine.getOwnedMembers().contains(node));

		Stereotype stereotype = UML.createStereotype();
		assertValid(stereotype);
		stateMachine.getNestedClassifiers().add(stereotype);
		assertSuperset(stateMachine.getOwnedMembers().contains(stereotype));

		StateMachine stateMachine2 = UML.createStateMachine();
		assertValid(stateMachine2);
		stateMachine.getNestedClassifiers().add(stateMachine2);
		assertSuperset(stateMachine.getOwnedMembers().contains(stateMachine2));

		Artifact artifact = UML.createArtifact();
		assertValid(artifact);
		stateMachine.getNestedClassifiers().add(artifact);
		assertSuperset(stateMachine.getOwnedMembers().contains(artifact));

		Collaboration collaboration = UML.createCollaboration();
		assertValid(collaboration);
		stateMachine.getNestedClassifiers().add(collaboration);
		assertSuperset(stateMachine.getOwnedMembers().contains(collaboration));
	}

	public void testOwnedReception() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		Reception reception = UML.createReception();
		assertValid(reception);
		stateMachine.getOwnedReceptions().add(reception);
		assertSuperset(stateMachine.getFeatures().contains(reception));
		assertSuperset(stateMachine.getOwnedMembers().contains(reception));
	}

	public void testSuperClass() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		EList<org.eclipse.uml2.uml.Class> class_s = stateMachine
			.getSuperClasses();
		EList<org.eclipse.uml2.uml.Class> class_s2 = stateMachine
			.getSuperClasses();
		assertSame(class_s, class_s2);
	}

	public void testSpecification() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		Reception reception = UML.createReception();
		assertValid(reception);
		stateMachine.setSpecification(reception);

		Operation operation = UML.createOperation();
		assertValid(operation);
		stateMachine.setSpecification(operation);
	}

	public void testOwnedParameter() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		Parameter parameter = UML.createParameter();
		assertValid(parameter);
		stateMachine.getOwnedParameters().add(parameter);
		assertSuperset(stateMachine.getOwnedMembers().contains(parameter));
	}

	public void testOwnedParameterSet() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		ParameterSet parameterSet = UML.createParameterSet();
		assertValid(parameterSet);
		stateMachine.getOwnedParameterSets().add(parameterSet);
		assertSuperset(stateMachine.getOwnedMembers().contains(parameterSet));
	}

	public void testPostcondition() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		IntervalConstraint intervalConstraint = UML.createIntervalConstraint();
		assertValid(intervalConstraint);
		stateMachine.getPostconditions().add(intervalConstraint);
		assertSuperset(
			stateMachine.getOwnedRules().contains(intervalConstraint));

		TimeConstraint timeConstraint = UML.createTimeConstraint();
		assertValid(timeConstraint);
		stateMachine.getPostconditions().add(timeConstraint);
		assertSuperset(stateMachine.getOwnedRules().contains(timeConstraint));

		InteractionConstraint interactionConstraint = UML
			.createInteractionConstraint();
		assertValid(interactionConstraint);
		stateMachine.getPostconditions().add(interactionConstraint);
		assertSuperset(
			stateMachine.getOwnedRules().contains(interactionConstraint));

		Constraint constraint = UML.createConstraint();
		assertValid(constraint);
		stateMachine.getPostconditions().add(constraint);
		assertSuperset(stateMachine.getOwnedRules().contains(constraint));

		DurationConstraint durationConstraint = UML.createDurationConstraint();
		assertValid(durationConstraint);
		stateMachine.getPostconditions().add(durationConstraint);
		assertSuperset(
			stateMachine.getOwnedRules().contains(durationConstraint));
	}

	public void testPrecondition() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		IntervalConstraint intervalConstraint = UML.createIntervalConstraint();
		assertValid(intervalConstraint);
		stateMachine.getPreconditions().add(intervalConstraint);
		assertSuperset(
			stateMachine.getOwnedRules().contains(intervalConstraint));

		TimeConstraint timeConstraint = UML.createTimeConstraint();
		assertValid(timeConstraint);
		stateMachine.getPreconditions().add(timeConstraint);
		assertSuperset(stateMachine.getOwnedRules().contains(timeConstraint));

		InteractionConstraint interactionConstraint = UML
			.createInteractionConstraint();
		assertValid(interactionConstraint);
		stateMachine.getPreconditions().add(interactionConstraint);
		assertSuperset(
			stateMachine.getOwnedRules().contains(interactionConstraint));

		Constraint constraint = UML.createConstraint();
		assertValid(constraint);
		stateMachine.getPreconditions().add(constraint);
		assertSuperset(stateMachine.getOwnedRules().contains(constraint));

		DurationConstraint durationConstraint = UML.createDurationConstraint();
		assertValid(durationConstraint);
		stateMachine.getPreconditions().add(durationConstraint);
		assertSuperset(
			stateMachine.getOwnedRules().contains(durationConstraint));
	}

	public void testConnectionPoint() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		Pseudostate pseudostate = UML.createPseudostate();
		assertValid(pseudostate);
		stateMachine.getConnectionPoints().add(pseudostate);
		assertSuperset(stateMachine.getOwnedMembers().contains(pseudostate));
	}

	public void testSubmachineState() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		FinalState finalState = UML.createFinalState();
		assertValid(finalState);
		stateMachine.getSubmachineStates().add(finalState);

		State state = UML.createState();
		assertValid(state);
		stateMachine.getSubmachineStates().add(state);
	}

	public void testRegion() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		Region region = UML.createRegion();
		assertValid(region);
		stateMachine.getRegions().add(region);
		assertSuperset(stateMachine.getOwnedMembers().contains(region));
	}

	public void testExtendedStateMachine() {
		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);

		ProtocolStateMachine protocolStateMachine = UML
			.createProtocolStateMachine();
		assertValid(protocolStateMachine);
		stateMachine.getExtendedStateMachines().add(protocolStateMachine);
		assertSuperset(stateMachine.getRedefinedClassifiers()
			.contains(protocolStateMachine));

		StateMachine stateMachine2 = UML.createStateMachine();
		assertValid(stateMachine2);
		stateMachine.getExtendedStateMachines().add(stateMachine2);
		assertSuperset(
			stateMachine.getRedefinedClassifiers().contains(stateMachine2));
	}

}