/*
 * 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.Abstraction;
import org.eclipse.uml2.uml.AcceptCallAction;
import org.eclipse.uml2.uml.AcceptEventAction;
import org.eclipse.uml2.uml.ActionExecutionSpecification;
import org.eclipse.uml2.uml.ActionInputPin;
import org.eclipse.uml2.uml.Activity;
import org.eclipse.uml2.uml.ActivityEdge;
import org.eclipse.uml2.uml.ActivityFinalNode;
import org.eclipse.uml2.uml.ActivityGroup;
import org.eclipse.uml2.uml.ActivityNode;
import org.eclipse.uml2.uml.ActivityParameterNode;
import org.eclipse.uml2.uml.ActivityPartition;
import org.eclipse.uml2.uml.Actor;
import org.eclipse.uml2.uml.AddStructuralFeatureValueAction;
import org.eclipse.uml2.uml.AddVariableValueAction;
import org.eclipse.uml2.uml.AnyReceiveEvent;
import org.eclipse.uml2.uml.Artifact;
import org.eclipse.uml2.uml.Association;
import org.eclipse.uml2.uml.AssociationClass;
import org.eclipse.uml2.uml.BehaviorExecutionSpecification;
import org.eclipse.uml2.uml.BroadcastSignalAction;
import org.eclipse.uml2.uml.CallBehaviorAction;
import org.eclipse.uml2.uml.CallEvent;
import org.eclipse.uml2.uml.CallOperationAction;
import org.eclipse.uml2.uml.CentralBufferNode;
import org.eclipse.uml2.uml.ChangeEvent;
import org.eclipse.uml2.uml.ClassifierTemplateParameter;
import org.eclipse.uml2.uml.Clause;
import org.eclipse.uml2.uml.ClearAssociationAction;
import org.eclipse.uml2.uml.ClearStructuralFeatureAction;
import org.eclipse.uml2.uml.ClearVariableAction;
import org.eclipse.uml2.uml.Collaboration;
import org.eclipse.uml2.uml.CollaborationUse;
import org.eclipse.uml2.uml.CombinedFragment;
import org.eclipse.uml2.uml.Comment;
import org.eclipse.uml2.uml.CommunicationPath;
import org.eclipse.uml2.uml.Component;
import org.eclipse.uml2.uml.ComponentRealization;
import org.eclipse.uml2.uml.ConditionalNode;
import org.eclipse.uml2.uml.ConnectableElementTemplateParameter;
import org.eclipse.uml2.uml.ConnectionPointReference;
import org.eclipse.uml2.uml.Connector;
import org.eclipse.uml2.uml.ConnectorEnd;
import org.eclipse.uml2.uml.ConsiderIgnoreFragment;
import org.eclipse.uml2.uml.Constraint;
import org.eclipse.uml2.uml.Continuation;
import org.eclipse.uml2.uml.ControlFlow;
import org.eclipse.uml2.uml.CreateLinkAction;
import org.eclipse.uml2.uml.CreateLinkObjectAction;
import org.eclipse.uml2.uml.CreateObjectAction;
import org.eclipse.uml2.uml.DataStoreNode;
import org.eclipse.uml2.uml.DataType;
import org.eclipse.uml2.uml.DecisionNode;
import org.eclipse.uml2.uml.Dependency;
import org.eclipse.uml2.uml.Deployment;
import org.eclipse.uml2.uml.DeploymentSpecification;
import org.eclipse.uml2.uml.DestroyLinkAction;
import org.eclipse.uml2.uml.DestroyObjectAction;
import org.eclipse.uml2.uml.DestructionOccurrenceSpecification;
import org.eclipse.uml2.uml.Device;
import org.eclipse.uml2.uml.Duration;
import org.eclipse.uml2.uml.DurationConstraint;
import org.eclipse.uml2.uml.DurationInterval;
import org.eclipse.uml2.uml.DurationObservation;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.ElementImport;
import org.eclipse.uml2.uml.Enumeration;
import org.eclipse.uml2.uml.EnumerationLiteral;
import org.eclipse.uml2.uml.ExceptionHandler;
import org.eclipse.uml2.uml.ExecutionEnvironment;
import org.eclipse.uml2.uml.ExecutionOccurrenceSpecification;
import org.eclipse.uml2.uml.ExpansionNode;
import org.eclipse.uml2.uml.ExpansionRegion;
import org.eclipse.uml2.uml.Expression;
import org.eclipse.uml2.uml.Extend;
import org.eclipse.uml2.uml.Extension;
import org.eclipse.uml2.uml.ExtensionEnd;
import org.eclipse.uml2.uml.ExtensionPoint;
import org.eclipse.uml2.uml.FinalState;
import org.eclipse.uml2.uml.FlowFinalNode;
import org.eclipse.uml2.uml.ForkNode;
import org.eclipse.uml2.uml.FunctionBehavior;
import org.eclipse.uml2.uml.Gate;
import org.eclipse.uml2.uml.GeneralOrdering;
import org.eclipse.uml2.uml.Generalization;
import org.eclipse.uml2.uml.GeneralizationSet;
import org.eclipse.uml2.uml.Image;
import org.eclipse.uml2.uml.Include;
import org.eclipse.uml2.uml.InformationFlow;
import org.eclipse.uml2.uml.InformationItem;
import org.eclipse.uml2.uml.InitialNode;
import org.eclipse.uml2.uml.InputPin;
import org.eclipse.uml2.uml.InstanceSpecification;
import org.eclipse.uml2.uml.InstanceValue;
import org.eclipse.uml2.uml.Interaction;
import org.eclipse.uml2.uml.InteractionConstraint;
import org.eclipse.uml2.uml.InteractionOperand;
import org.eclipse.uml2.uml.InteractionUse;
import org.eclipse.uml2.uml.Interface;
import org.eclipse.uml2.uml.InterfaceRealization;
import org.eclipse.uml2.uml.InterruptibleActivityRegion;
import org.eclipse.uml2.uml.Interval;
import org.eclipse.uml2.uml.IntervalConstraint;
import org.eclipse.uml2.uml.JoinNode;
import org.eclipse.uml2.uml.Lifeline;
import org.eclipse.uml2.uml.LinkEndCreationData;
import org.eclipse.uml2.uml.LinkEndData;
import org.eclipse.uml2.uml.LinkEndDestructionData;
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.LoopNode;
import org.eclipse.uml2.uml.Manifestation;
import org.eclipse.uml2.uml.MergeNode;
import org.eclipse.uml2.uml.Message;
import org.eclipse.uml2.uml.MessageOccurrenceSpecification;
import org.eclipse.uml2.uml.Model;
import org.eclipse.uml2.uml.Node;
import org.eclipse.uml2.uml.ObjectFlow;
import org.eclipse.uml2.uml.OccurrenceSpecification;
import org.eclipse.uml2.uml.OpaqueAction;
import org.eclipse.uml2.uml.OpaqueBehavior;
import org.eclipse.uml2.uml.OpaqueExpression;
import org.eclipse.uml2.uml.Operation;
import org.eclipse.uml2.uml.OperationTemplateParameter;
import org.eclipse.uml2.uml.OutputPin;
import org.eclipse.uml2.uml.PackageImport;
import org.eclipse.uml2.uml.PackageMerge;
import org.eclipse.uml2.uml.Parameter;
import org.eclipse.uml2.uml.ParameterSet;
import org.eclipse.uml2.uml.PartDecomposition;
import org.eclipse.uml2.uml.Port;
import org.eclipse.uml2.uml.PrimitiveType;
import org.eclipse.uml2.uml.Profile;
import org.eclipse.uml2.uml.ProfileApplication;
import org.eclipse.uml2.uml.Property;
import org.eclipse.uml2.uml.ProtocolConformance;
import org.eclipse.uml2.uml.ProtocolStateMachine;
import org.eclipse.uml2.uml.ProtocolTransition;
import org.eclipse.uml2.uml.Pseudostate;
import org.eclipse.uml2.uml.QualifierValue;
import org.eclipse.uml2.uml.RaiseExceptionAction;
import org.eclipse.uml2.uml.ReadExtentAction;
import org.eclipse.uml2.uml.ReadIsClassifiedObjectAction;
import org.eclipse.uml2.uml.ReadLinkAction;
import org.eclipse.uml2.uml.ReadLinkObjectEndAction;
import org.eclipse.uml2.uml.ReadLinkObjectEndQualifierAction;
import org.eclipse.uml2.uml.ReadSelfAction;
import org.eclipse.uml2.uml.ReadStructuralFeatureAction;
import org.eclipse.uml2.uml.ReadVariableAction;
import org.eclipse.uml2.uml.Realization;
import org.eclipse.uml2.uml.Reception;
import org.eclipse.uml2.uml.ReclassifyObjectAction;
import org.eclipse.uml2.uml.RedefinableTemplateSignature;
import org.eclipse.uml2.uml.ReduceAction;
import org.eclipse.uml2.uml.Region;
import org.eclipse.uml2.uml.RemoveStructuralFeatureValueAction;
import org.eclipse.uml2.uml.RemoveVariableValueAction;
import org.eclipse.uml2.uml.ReplyAction;
import org.eclipse.uml2.uml.SendObjectAction;
import org.eclipse.uml2.uml.SendSignalAction;
import org.eclipse.uml2.uml.SequenceNode;
import org.eclipse.uml2.uml.Signal;
import org.eclipse.uml2.uml.SignalEvent;
import org.eclipse.uml2.uml.Slot;
import org.eclipse.uml2.uml.StartClassifierBehaviorAction;
import org.eclipse.uml2.uml.StartObjectBehaviorAction;
import org.eclipse.uml2.uml.State;
import org.eclipse.uml2.uml.StateInvariant;
import org.eclipse.uml2.uml.StateMachine;
import org.eclipse.uml2.uml.Stereotype;
import org.eclipse.uml2.uml.StringExpression;
import org.eclipse.uml2.uml.StructuredActivityNode;
import org.eclipse.uml2.uml.Substitution;
import org.eclipse.uml2.uml.TemplateBinding;
import org.eclipse.uml2.uml.TemplateParameter;
import org.eclipse.uml2.uml.TemplateParameterSubstitution;
import org.eclipse.uml2.uml.TemplateSignature;
import org.eclipse.uml2.uml.TestIdentityAction;
import org.eclipse.uml2.uml.TimeConstraint;
import org.eclipse.uml2.uml.TimeEvent;
import org.eclipse.uml2.uml.TimeExpression;
import org.eclipse.uml2.uml.TimeInterval;
import org.eclipse.uml2.uml.TimeObservation;
import org.eclipse.uml2.uml.Transition;
import org.eclipse.uml2.uml.Trigger;
import org.eclipse.uml2.uml.UnmarshallAction;
import org.eclipse.uml2.uml.Usage;
import org.eclipse.uml2.uml.UseCase;
import org.eclipse.uml2.uml.ValuePin;
import org.eclipse.uml2.uml.ValueSpecificationAction;
import org.eclipse.uml2.uml.Variable;

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

	public void testEAnnotations() {
		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);

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

	public void testOwnedComment() {
		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);

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

	public void testOwnedElement() {
		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);
		EList<Element> elements = activityPartition.getOwnedElements();
		EList<Element> elements2 = activityPartition.getOwnedElements();
		assertSame(elements, elements2);
	}

	public void testClientDependency() {
		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);
		EList<Dependency> dependencys = activityPartition
			.getClientDependencies();
		EList<Dependency> dependencys2 = activityPartition
			.getClientDependencies();
		assertSame(dependencys, dependencys2);
	}

	public void testNameExpression() {
		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);

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

	public void testContainedEdge() {
		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);
		EList<ActivityEdge> activityEdges = activityPartition
			.getContainedEdges();
		EList<ActivityEdge> activityEdges2 = activityPartition
			.getContainedEdges();
		assertSame(activityEdges, activityEdges2);
	}

	public void testContainedNode() {
		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);
		EList<ActivityNode> activityNodes = activityPartition
			.getContainedNodes();
		EList<ActivityNode> activityNodes2 = activityPartition
			.getContainedNodes();
		assertSame(activityNodes, activityNodes2);
	}

	public void testSubgroup() {
		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);
		EList<ActivityGroup> activityGroups = activityPartition.getSubgroups();
		EList<ActivityGroup> activityGroups2 = activityPartition.getSubgroups();
		assertSame(activityGroups, activityGroups2);
	}

	public void testNode() {
		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);

		StartClassifierBehaviorAction startClassifierBehaviorAction = UML
			.createStartClassifierBehaviorAction();
		assertValid(startClassifierBehaviorAction);
		activityPartition.getNodes().add(startClassifierBehaviorAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(startClassifierBehaviorAction));

		RemoveVariableValueAction removeVariableValueAction = UML
			.createRemoveVariableValueAction();
		assertValid(removeVariableValueAction);
		activityPartition.getNodes().add(removeVariableValueAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(removeVariableValueAction));

		ReadSelfAction readSelfAction = UML.createReadSelfAction();
		assertValid(readSelfAction);
		activityPartition.getNodes().add(readSelfAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(readSelfAction));

		InputPin inputPin = UML.createInputPin();
		assertValid(inputPin);
		activityPartition.getNodes().add(inputPin);
		assertSuperset(
			activityPartition.getContainedNodes().contains(inputPin));

		ReadLinkObjectEndQualifierAction readLinkObjectEndQualifierAction = UML
			.createReadLinkObjectEndQualifierAction();
		assertValid(readLinkObjectEndQualifierAction);
		activityPartition.getNodes().add(readLinkObjectEndQualifierAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(readLinkObjectEndQualifierAction));

		JoinNode joinNode = UML.createJoinNode();
		assertValid(joinNode);
		activityPartition.getNodes().add(joinNode);
		assertSuperset(
			activityPartition.getContainedNodes().contains(joinNode));

		CreateLinkObjectAction createLinkObjectAction = UML
			.createCreateLinkObjectAction();
		assertValid(createLinkObjectAction);
		activityPartition.getNodes().add(createLinkObjectAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(createLinkObjectAction));

		SendSignalAction sendSignalAction = UML.createSendSignalAction();
		assertValid(sendSignalAction);
		activityPartition.getNodes().add(sendSignalAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(sendSignalAction));

		ReadLinkAction readLinkAction = UML.createReadLinkAction();
		assertValid(readLinkAction);
		activityPartition.getNodes().add(readLinkAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(readLinkAction));

		ReplyAction replyAction = UML.createReplyAction();
		assertValid(replyAction);
		activityPartition.getNodes().add(replyAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(replyAction));

		ClearAssociationAction clearAssociationAction = UML
			.createClearAssociationAction();
		assertValid(clearAssociationAction);
		activityPartition.getNodes().add(clearAssociationAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(clearAssociationAction));

		FlowFinalNode flowFinalNode = UML.createFlowFinalNode();
		assertValid(flowFinalNode);
		activityPartition.getNodes().add(flowFinalNode);
		assertSuperset(
			activityPartition.getContainedNodes().contains(flowFinalNode));

		ClearStructuralFeatureAction clearStructuralFeatureAction = UML
			.createClearStructuralFeatureAction();
		assertValid(clearStructuralFeatureAction);
		activityPartition.getNodes().add(clearStructuralFeatureAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(clearStructuralFeatureAction));

		ExpansionRegion expansionRegion = UML.createExpansionRegion();
		assertValid(expansionRegion);
		activityPartition.getNodes().add(expansionRegion);
		assertSuperset(
			activityPartition.getContainedNodes().contains(expansionRegion));

		StructuredActivityNode structuredActivityNode = UML
			.createStructuredActivityNode();
		assertValid(structuredActivityNode);
		activityPartition.getNodes().add(structuredActivityNode);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(structuredActivityNode));

		ValuePin valuePin = UML.createValuePin();
		assertValid(valuePin);
		activityPartition.getNodes().add(valuePin);
		assertSuperset(
			activityPartition.getContainedNodes().contains(valuePin));

		StartObjectBehaviorAction startObjectBehaviorAction = UML
			.createStartObjectBehaviorAction();
		assertValid(startObjectBehaviorAction);
		activityPartition.getNodes().add(startObjectBehaviorAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(startObjectBehaviorAction));

		ForkNode forkNode = UML.createForkNode();
		assertValid(forkNode);
		activityPartition.getNodes().add(forkNode);
		assertSuperset(
			activityPartition.getContainedNodes().contains(forkNode));

		DecisionNode decisionNode = UML.createDecisionNode();
		assertValid(decisionNode);
		activityPartition.getNodes().add(decisionNode);
		assertSuperset(
			activityPartition.getContainedNodes().contains(decisionNode));

		CallBehaviorAction callBehaviorAction = UML.createCallBehaviorAction();
		assertValid(callBehaviorAction);
		activityPartition.getNodes().add(callBehaviorAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(callBehaviorAction));

		ConditionalNode conditionalNode = UML.createConditionalNode();
		assertValid(conditionalNode);
		activityPartition.getNodes().add(conditionalNode);
		assertSuperset(
			activityPartition.getContainedNodes().contains(conditionalNode));

		ReadExtentAction readExtentAction = UML.createReadExtentAction();
		assertValid(readExtentAction);
		activityPartition.getNodes().add(readExtentAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(readExtentAction));

		ActionInputPin actionInputPin = UML.createActionInputPin();
		assertValid(actionInputPin);
		activityPartition.getNodes().add(actionInputPin);
		assertSuperset(
			activityPartition.getContainedNodes().contains(actionInputPin));

		ReadIsClassifiedObjectAction readIsClassifiedObjectAction = UML
			.createReadIsClassifiedObjectAction();
		assertValid(readIsClassifiedObjectAction);
		activityPartition.getNodes().add(readIsClassifiedObjectAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(readIsClassifiedObjectAction));

		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);
		activityPartition.getNodes().add(activityParameterNode);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(activityParameterNode));

		AddStructuralFeatureValueAction addStructuralFeatureValueAction = UML
			.createAddStructuralFeatureValueAction();
		assertValid(addStructuralFeatureValueAction);
		activityPartition.getNodes().add(addStructuralFeatureValueAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(addStructuralFeatureValueAction));

		ReadVariableAction readVariableAction = UML.createReadVariableAction();
		assertValid(readVariableAction);
		activityPartition.getNodes().add(readVariableAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(readVariableAction));

		ClearVariableAction clearVariableAction = UML
			.createClearVariableAction();
		assertValid(clearVariableAction);
		activityPartition.getNodes().add(clearVariableAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(clearVariableAction));

		RemoveStructuralFeatureValueAction removeStructuralFeatureValueAction = UML
			.createRemoveStructuralFeatureValueAction();
		assertValid(removeStructuralFeatureValueAction);
		activityPartition.getNodes().add(removeStructuralFeatureValueAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(removeStructuralFeatureValueAction));

		CreateLinkAction createLinkAction = UML.createCreateLinkAction();
		assertValid(createLinkAction);
		activityPartition.getNodes().add(createLinkAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(createLinkAction));

		ReclassifyObjectAction reclassifyObjectAction = UML
			.createReclassifyObjectAction();
		assertValid(reclassifyObjectAction);
		activityPartition.getNodes().add(reclassifyObjectAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(reclassifyObjectAction));

		DataStoreNode dataStoreNode = UML.createDataStoreNode();
		assertValid(dataStoreNode);
		activityPartition.getNodes().add(dataStoreNode);
		assertSuperset(
			activityPartition.getContainedNodes().contains(dataStoreNode));

		SendObjectAction sendObjectAction = UML.createSendObjectAction();
		assertValid(sendObjectAction);
		activityPartition.getNodes().add(sendObjectAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(sendObjectAction));

		ReduceAction reduceAction = UML.createReduceAction();
		assertValid(reduceAction);
		activityPartition.getNodes().add(reduceAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(reduceAction));

		AcceptEventAction acceptEventAction = UML.createAcceptEventAction();
		assertValid(acceptEventAction);
		activityPartition.getNodes().add(acceptEventAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(acceptEventAction));

		DestroyLinkAction destroyLinkAction = UML.createDestroyLinkAction();
		assertValid(destroyLinkAction);
		activityPartition.getNodes().add(destroyLinkAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(destroyLinkAction));

		ExpansionNode expansionNode = UML.createExpansionNode();
		assertValid(expansionNode);
		activityPartition.getNodes().add(expansionNode);
		assertSuperset(
			activityPartition.getContainedNodes().contains(expansionNode));

		InitialNode initialNode = UML.createInitialNode();
		assertValid(initialNode);
		activityPartition.getNodes().add(initialNode);
		assertSuperset(
			activityPartition.getContainedNodes().contains(initialNode));

		TestIdentityAction testIdentityAction = UML.createTestIdentityAction();
		assertValid(testIdentityAction);
		activityPartition.getNodes().add(testIdentityAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(testIdentityAction));

		OutputPin outputPin = UML.createOutputPin();
		assertValid(outputPin);
		activityPartition.getNodes().add(outputPin);
		assertSuperset(
			activityPartition.getContainedNodes().contains(outputPin));

		CentralBufferNode centralBufferNode = UML.createCentralBufferNode();
		assertValid(centralBufferNode);
		activityPartition.getNodes().add(centralBufferNode);
		assertSuperset(
			activityPartition.getContainedNodes().contains(centralBufferNode));

		BroadcastSignalAction broadcastSignalAction = UML
			.createBroadcastSignalAction();
		assertValid(broadcastSignalAction);
		activityPartition.getNodes().add(broadcastSignalAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(broadcastSignalAction));

		RaiseExceptionAction raiseExceptionAction = UML
			.createRaiseExceptionAction();
		assertValid(raiseExceptionAction);
		activityPartition.getNodes().add(raiseExceptionAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(raiseExceptionAction));

		ActivityFinalNode activityFinalNode = UML.createActivityFinalNode();
		assertValid(activityFinalNode);
		activityPartition.getNodes().add(activityFinalNode);
		assertSuperset(
			activityPartition.getContainedNodes().contains(activityFinalNode));

		CallOperationAction callOperationAction = UML
			.createCallOperationAction();
		assertValid(callOperationAction);
		activityPartition.getNodes().add(callOperationAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(callOperationAction));

		LoopNode loopNode = UML.createLoopNode();
		assertValid(loopNode);
		activityPartition.getNodes().add(loopNode);
		assertSuperset(
			activityPartition.getContainedNodes().contains(loopNode));

		ValueSpecificationAction valueSpecificationAction = UML
			.createValueSpecificationAction();
		assertValid(valueSpecificationAction);
		activityPartition.getNodes().add(valueSpecificationAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(valueSpecificationAction));

		AcceptCallAction acceptCallAction = UML.createAcceptCallAction();
		assertValid(acceptCallAction);
		activityPartition.getNodes().add(acceptCallAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(acceptCallAction));

		AddVariableValueAction addVariableValueAction = UML
			.createAddVariableValueAction();
		assertValid(addVariableValueAction);
		activityPartition.getNodes().add(addVariableValueAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(addVariableValueAction));

		ReadLinkObjectEndAction readLinkObjectEndAction = UML
			.createReadLinkObjectEndAction();
		assertValid(readLinkObjectEndAction);
		activityPartition.getNodes().add(readLinkObjectEndAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(readLinkObjectEndAction));

		UnmarshallAction unmarshallAction = UML.createUnmarshallAction();
		assertValid(unmarshallAction);
		activityPartition.getNodes().add(unmarshallAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(unmarshallAction));

		OpaqueAction opaqueAction = UML.createOpaqueAction();
		assertValid(opaqueAction);
		activityPartition.getNodes().add(opaqueAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(opaqueAction));

		MergeNode mergeNode = UML.createMergeNode();
		assertValid(mergeNode);
		activityPartition.getNodes().add(mergeNode);
		assertSuperset(
			activityPartition.getContainedNodes().contains(mergeNode));

		SequenceNode sequenceNode = UML.createSequenceNode();
		assertValid(sequenceNode);
		activityPartition.getNodes().add(sequenceNode);
		assertSuperset(
			activityPartition.getContainedNodes().contains(sequenceNode));

		CreateObjectAction createObjectAction = UML.createCreateObjectAction();
		assertValid(createObjectAction);
		activityPartition.getNodes().add(createObjectAction);
		assertSuperset(
			activityPartition.getContainedNodes().contains(createObjectAction));

		DestroyObjectAction destroyObjectAction = UML
			.createDestroyObjectAction();
		assertValid(destroyObjectAction);
		activityPartition.getNodes().add(destroyObjectAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(destroyObjectAction));

		ReadStructuralFeatureAction readStructuralFeatureAction = UML
			.createReadStructuralFeatureAction();
		assertValid(readStructuralFeatureAction);
		activityPartition.getNodes().add(readStructuralFeatureAction);
		assertSuperset(activityPartition.getContainedNodes()
			.contains(readStructuralFeatureAction));
	}

	public void testRepresents() {
		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);

		Activity activity = UML.createActivity();
		assertValid(activity);
		activityPartition.setRepresents(activity);

		CommunicationPath communicationPath = UML.createCommunicationPath();
		assertValid(communicationPath);
		activityPartition.setRepresents(communicationPath);

		ActivityPartition activityPartition2 = UML.createActivityPartition();
		assertValid(activityPartition2);

		InputPin inputPin = UML.createInputPin();
		assertValid(inputPin);
		activityPartition2.setRepresents(inputPin);

		ReadLinkObjectEndQualifierAction readLinkObjectEndQualifierAction = UML
			.createReadLinkObjectEndQualifierAction();
		assertValid(readLinkObjectEndQualifierAction);
		activityPartition2.setRepresents(readLinkObjectEndQualifierAction);

		ActivityPartition activityPartition3 = UML.createActivityPartition();
		assertValid(activityPartition3);

		Component component = UML.createComponent();
		assertValid(component);
		activityPartition3.setRepresents(component);

		DurationObservation durationObservation = UML
			.createDurationObservation();
		assertValid(durationObservation);
		activityPartition3.setRepresents(durationObservation);

		ActivityPartition activityPartition4 = UML.createActivityPartition();
		assertValid(activityPartition4);

		CallEvent callEvent = UML.createCallEvent();
		assertValid(callEvent);
		activityPartition4.setRepresents(callEvent);

		JoinNode joinNode = UML.createJoinNode();
		assertValid(joinNode);
		activityPartition4.setRepresents(joinNode);

		ActivityPartition activityPartition5 = UML.createActivityPartition();
		assertValid(activityPartition5);

		CreateLinkObjectAction createLinkObjectAction = UML
			.createCreateLinkObjectAction();
		assertValid(createLinkObjectAction);
		activityPartition5.setRepresents(createLinkObjectAction);

		ReadLinkAction readLinkAction = UML.createReadLinkAction();
		assertValid(readLinkAction);
		activityPartition5.setRepresents(readLinkAction);

		ActivityPartition activityPartition6 = UML.createActivityPartition();
		assertValid(activityPartition6);

		Model model = UML.createModel();
		assertValid(model);
		activityPartition6.setRepresents(model);

		Trigger trigger = UML.createTrigger();
		assertValid(trigger);
		activityPartition6.setRepresents(trigger);

		ActivityPartition activityPartition7 = UML.createActivityPartition();
		assertValid(activityPartition7);

		AssociationClass associationClass = UML.createAssociationClass();
		assertValid(associationClass);
		activityPartition7.setRepresents(associationClass);

		ClassifierTemplateParameter classifierTemplateParameter = UML
			.createClassifierTemplateParameter();
		assertValid(classifierTemplateParameter);
		activityPartition7.setRepresents(classifierTemplateParameter);

		ActivityPartition activityPartition8 = UML.createActivityPartition();
		assertValid(activityPartition8);

		ClearStructuralFeatureAction clearStructuralFeatureAction = UML
			.createClearStructuralFeatureAction();
		assertValid(clearStructuralFeatureAction);
		activityPartition8.setRepresents(clearStructuralFeatureAction);

		StructuredActivityNode structuredActivityNode = UML
			.createStructuredActivityNode();
		assertValid(structuredActivityNode);
		activityPartition8.setRepresents(structuredActivityNode);

		ActivityPartition activityPartition9 = UML.createActivityPartition();
		assertValid(activityPartition9);

		ForkNode forkNode = UML.createForkNode();
		assertValid(forkNode);
		activityPartition9.setRepresents(forkNode);

		TimeConstraint timeConstraint = UML.createTimeConstraint();
		assertValid(timeConstraint);
		activityPartition9.setRepresents(timeConstraint);

		ActivityPartition activityPartition10 = UML.createActivityPartition();
		assertValid(activityPartition10);

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

		ConsiderIgnoreFragment considerIgnoreFragment = UML
			.createConsiderIgnoreFragment();
		assertValid(considerIgnoreFragment);
		activityPartition10.setRepresents(considerIgnoreFragment);

		ActivityPartition activityPartition11 = UML.createActivityPartition();
		assertValid(activityPartition11);

		ProtocolConformance protocolConformance = UML
			.createProtocolConformance();
		assertValid(protocolConformance);
		activityPartition11.setRepresents(protocolConformance);

		ReadExtentAction readExtentAction = UML.createReadExtentAction();
		assertValid(readExtentAction);
		activityPartition11.setRepresents(readExtentAction);

		ActivityPartition activityPartition12 = UML.createActivityPartition();
		assertValid(activityPartition12);

		ActionInputPin actionInputPin = UML.createActionInputPin();
		assertValid(actionInputPin);
		activityPartition12.setRepresents(actionInputPin);

		Artifact artifact = UML.createArtifact();
		assertValid(artifact);
		activityPartition12.setRepresents(artifact);

		ActivityPartition activityPartition13 = UML.createActivityPartition();
		assertValid(activityPartition13);

		InformationFlow informationFlow = UML.createInformationFlow();
		assertValid(informationFlow);
		activityPartition13.setRepresents(informationFlow);

		ClearVariableAction clearVariableAction = UML
			.createClearVariableAction();
		assertValid(clearVariableAction);
		activityPartition13.setRepresents(clearVariableAction);

		ActivityPartition activityPartition14 = UML.createActivityPartition();
		assertValid(activityPartition14);

		CreateLinkAction createLinkAction = UML.createCreateLinkAction();
		assertValid(createLinkAction);
		activityPartition14.setRepresents(createLinkAction);

		SendObjectAction sendObjectAction = UML.createSendObjectAction();
		assertValid(sendObjectAction);
		activityPartition14.setRepresents(sendObjectAction);

		ActivityPartition activityPartition15 = UML.createActivityPartition();
		assertValid(activityPartition15);

		LinkEndData linkEndData = UML.createLinkEndData();
		assertValid(linkEndData);
		activityPartition15.setRepresents(linkEndData);

		ControlFlow controlFlow = UML.createControlFlow();
		assertValid(controlFlow);
		activityPartition15.setRepresents(controlFlow);

		ActivityPartition activityPartition16 = UML.createActivityPartition();
		assertValid(activityPartition16);

		DeploymentSpecification deploymentSpecification = UML
			.createDeploymentSpecification();
		assertValid(deploymentSpecification);
		activityPartition16.setRepresents(deploymentSpecification);

		PartDecomposition partDecomposition = UML.createPartDecomposition();
		assertValid(partDecomposition);
		activityPartition16.setRepresents(partDecomposition);

		ActivityPartition activityPartition17 = UML.createActivityPartition();
		assertValid(activityPartition17);

		Image image = UML.createImage();
		assertValid(image);
		activityPartition17.setRepresents(image);

		DestroyLinkAction destroyLinkAction = UML.createDestroyLinkAction();
		assertValid(destroyLinkAction);
		activityPartition17.setRepresents(destroyLinkAction);

		ActivityPartition activityPartition18 = UML.createActivityPartition();
		assertValid(activityPartition18);

		ExpansionNode expansionNode = UML.createExpansionNode();
		assertValid(expansionNode);
		activityPartition18.setRepresents(expansionNode);

		TimeInterval timeInterval = UML.createTimeInterval();
		assertValid(timeInterval);
		activityPartition18.setRepresents(timeInterval);

		ActivityPartition activityPartition19 = UML.createActivityPartition();
		assertValid(activityPartition19);

		DataType dataType = UML.createDataType();
		assertValid(dataType);
		activityPartition19.setRepresents(dataType);

		Substitution substitution = UML.createSubstitution();
		assertValid(substitution);
		activityPartition19.setRepresents(substitution);

		ActivityPartition activityPartition20 = UML.createActivityPartition();
		assertValid(activityPartition20);

		LiteralBoolean literalBoolean = UML.createLiteralBoolean();
		assertValid(literalBoolean);
		activityPartition20.setRepresents(literalBoolean);

		DurationConstraint durationConstraint = UML.createDurationConstraint();
		assertValid(durationConstraint);
		activityPartition20.setRepresents(durationConstraint);

		ActivityPartition activityPartition21 = UML.createActivityPartition();
		assertValid(activityPartition21);

		LiteralNull literalNull = UML.createLiteralNull();
		assertValid(literalNull);
		activityPartition21.setRepresents(literalNull);

		CallOperationAction callOperationAction = UML
			.createCallOperationAction();
		assertValid(callOperationAction);
		activityPartition21.setRepresents(callOperationAction);

		ActivityPartition activityPartition22 = UML.createActivityPartition();
		assertValid(activityPartition22);

		Node node = UML.createNode();
		assertValid(node);
		activityPartition22.setRepresents(node);

		Constraint constraint = UML.createConstraint();
		assertValid(constraint);
		activityPartition22.setRepresents(constraint);

		ActivityPartition activityPartition23 = UML.createActivityPartition();
		assertValid(activityPartition23);

		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		activityPartition23.setRepresents(stateMachine);

		Interface interface_ = UML.createInterface();
		assertValid(interface_);
		activityPartition23.setRepresents(interface_);

		ActivityPartition activityPartition24 = UML.createActivityPartition();
		assertValid(activityPartition24);

		StartClassifierBehaviorAction startClassifierBehaviorAction = UML
			.createStartClassifierBehaviorAction();
		assertValid(startClassifierBehaviorAction);
		activityPartition24.setRepresents(startClassifierBehaviorAction);

		RemoveVariableValueAction removeVariableValueAction = UML
			.createRemoveVariableValueAction();
		assertValid(removeVariableValueAction);
		activityPartition24.setRepresents(removeVariableValueAction);

		ActivityPartition activityPartition25 = UML.createActivityPartition();
		assertValid(activityPartition25);

		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);
		activityPartition25.setRepresents(redefinableTemplateSignature);

		ExecutionOccurrenceSpecification executionOccurrenceSpecification = UML
			.createExecutionOccurrenceSpecification();
		assertValid(executionOccurrenceSpecification);
		activityPartition25.setRepresents(executionOccurrenceSpecification);

		ActivityPartition activityPartition26 = UML.createActivityPartition();
		assertValid(activityPartition26);

		Variable variable = UML.createVariable();
		assertValid(variable);
		activityPartition26.setRepresents(variable);

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

		ActivityPartition activityPartition27 = UML.createActivityPartition();
		assertValid(activityPartition27);

		ExpansionRegion expansionRegion = UML.createExpansionRegion();
		assertValid(expansionRegion);
		activityPartition27.setRepresents(expansionRegion);

		TemplateParameter templateParameter = UML.createTemplateParameter();
		assertValid(templateParameter);
		activityPartition27.setRepresents(templateParameter);

		ActivityPartition activityPartition28 = UML.createActivityPartition();
		assertValid(activityPartition28);

		StartObjectBehaviorAction startObjectBehaviorAction = UML
			.createStartObjectBehaviorAction();
		assertValid(startObjectBehaviorAction);
		activityPartition28.setRepresents(startObjectBehaviorAction);

		Profile profile = UML.createProfile();
		assertValid(profile);
		activityPartition28.setRepresents(profile);

		ActivityPartition activityPartition29 = UML.createActivityPartition();
		assertValid(activityPartition29);

		Message message = UML.createMessage();
		assertValid(message);
		activityPartition29.setRepresents(message);

		Continuation continuation = UML.createContinuation();
		assertValid(continuation);
		activityPartition29.setRepresents(continuation);

		ActivityPartition activityPartition30 = UML.createActivityPartition();
		assertValid(activityPartition30);

		ObjectFlow objectFlow = UML.createObjectFlow();
		assertValid(objectFlow);
		activityPartition30.setRepresents(objectFlow);

		StateInvariant stateInvariant = UML.createStateInvariant();
		assertValid(stateInvariant);
		activityPartition30.setRepresents(stateInvariant);

		ActivityPartition activityPartition31 = UML.createActivityPartition();
		assertValid(activityPartition31);

		AddStructuralFeatureValueAction addStructuralFeatureValueAction = UML
			.createAddStructuralFeatureValueAction();
		assertValid(addStructuralFeatureValueAction);
		activityPartition31.setRepresents(addStructuralFeatureValueAction);

		ConnectorEnd connectorEnd = UML.createConnectorEnd();
		assertValid(connectorEnd);
		activityPartition31.setRepresents(connectorEnd);

		ActivityPartition activityPartition32 = UML.createActivityPartition();
		assertValid(activityPartition32);

		LinkEndCreationData linkEndCreationData = UML
			.createLinkEndCreationData();
		assertValid(linkEndCreationData);
		activityPartition32.setRepresents(linkEndCreationData);

		ConnectableElementTemplateParameter connectableElementTemplateParameter = UML
			.createConnectableElementTemplateParameter();
		assertValid(connectableElementTemplateParameter);
		activityPartition32.setRepresents(connectableElementTemplateParameter);

		ActivityPartition activityPartition33 = UML.createActivityPartition();
		assertValid(activityPartition33);

		TemplateBinding templateBinding = UML.createTemplateBinding();
		assertValid(templateBinding);
		activityPartition33.setRepresents(templateBinding);

		OpaqueExpression opaqueExpression = UML.createOpaqueExpression();
		assertValid(opaqueExpression);
		activityPartition33.setRepresents(opaqueExpression);

		ActivityPartition activityPartition34 = UML.createActivityPartition();
		assertValid(activityPartition34);

		TimeEvent timeEvent = UML.createTimeEvent();
		assertValid(timeEvent);
		activityPartition34.setRepresents(timeEvent);

		GeneralOrdering generalOrdering = UML.createGeneralOrdering();
		assertValid(generalOrdering);
		activityPartition34.setRepresents(generalOrdering);

		ActivityPartition activityPartition35 = UML.createActivityPartition();
		assertValid(activityPartition35);

		MessageOccurrenceSpecification messageOccurrenceSpecification = UML
			.createMessageOccurrenceSpecification();
		assertValid(messageOccurrenceSpecification);
		activityPartition35.setRepresents(messageOccurrenceSpecification);

		LiteralInteger literalInteger = UML.createLiteralInteger();
		assertValid(literalInteger);
		activityPartition35.setRepresents(literalInteger);

		ActivityPartition activityPartition36 = UML.createActivityPartition();
		assertValid(activityPartition36);

		Slot slot = UML.createSlot();
		assertValid(slot);
		activityPartition36.setRepresents(slot);

		CentralBufferNode centralBufferNode = UML.createCentralBufferNode();
		assertValid(centralBufferNode);
		activityPartition36.setRepresents(centralBufferNode);

		ActivityPartition activityPartition37 = UML.createActivityPartition();
		assertValid(activityPartition37);

		Extension extension = UML.createExtension();
		assertValid(extension);
		activityPartition37.setRepresents(extension);

		ExtensionPoint extensionPoint = UML.createExtensionPoint();
		assertValid(extensionPoint);
		activityPartition37.setRepresents(extensionPoint);

		ActivityPartition activityPartition38 = UML.createActivityPartition();
		assertValid(activityPartition38);

		ElementImport elementImport = UML.createElementImport();
		assertValid(elementImport);
		activityPartition38.setRepresents(elementImport);

		Dependency dependency = UML.createDependency();
		assertValid(dependency);
		activityPartition38.setRepresents(dependency);

		ActivityPartition activityPartition39 = UML.createActivityPartition();
		assertValid(activityPartition39);

		Expression expression = UML.createExpression();
		assertValid(expression);
		activityPartition39.setRepresents(expression);

		BehaviorExecutionSpecification behaviorExecutionSpecification = UML
			.createBehaviorExecutionSpecification();
		assertValid(behaviorExecutionSpecification);
		activityPartition39.setRepresents(behaviorExecutionSpecification);

		ActivityPartition activityPartition40 = UML.createActivityPartition();
		assertValid(activityPartition40);

		AcceptCallAction acceptCallAction = UML.createAcceptCallAction();
		assertValid(acceptCallAction);
		activityPartition40.setRepresents(acceptCallAction);

		ReadLinkObjectEndAction readLinkObjectEndAction = UML
			.createReadLinkObjectEndAction();
		assertValid(readLinkObjectEndAction);
		activityPartition40.setRepresents(readLinkObjectEndAction);

		ActivityPartition activityPartition41 = UML.createActivityPartition();
		assertValid(activityPartition41);

		OpaqueAction opaqueAction = UML.createOpaqueAction();
		assertValid(opaqueAction);
		activityPartition41.setRepresents(opaqueAction);

		PackageImport packageImport = UML.createPackageImport();
		assertValid(packageImport);
		activityPartition41.setRepresents(packageImport);

		ActivityPartition activityPartition42 = UML.createActivityPartition();
		assertValid(activityPartition42);

		StringExpression stringExpression = UML.createStringExpression();
		assertValid(stringExpression);
		activityPartition42.setRepresents(stringExpression);

		MergeNode mergeNode = UML.createMergeNode();
		assertValid(mergeNode);
		activityPartition42.setRepresents(mergeNode);

		ActivityPartition activityPartition43 = UML.createActivityPartition();
		assertValid(activityPartition43);

		TemplateSignature templateSignature = UML.createTemplateSignature();
		assertValid(templateSignature);
		activityPartition43.setRepresents(templateSignature);

		ChangeEvent changeEvent = UML.createChangeEvent();
		assertValid(changeEvent);
		activityPartition43.setRepresents(changeEvent);

		ActivityPartition activityPartition44 = UML.createActivityPartition();
		assertValid(activityPartition44);

		Stereotype stereotype = UML.createStereotype();
		assertValid(stereotype);
		activityPartition44.setRepresents(stereotype);

		Comment comment = UML.createComment();
		assertValid(comment);
		activityPartition44.setRepresents(comment);

		ActivityPartition activityPartition45 = UML.createActivityPartition();
		assertValid(activityPartition45);

		ReadSelfAction readSelfAction = UML.createReadSelfAction();
		assertValid(readSelfAction);
		activityPartition45.setRepresents(readSelfAction);

		ActivityPartition activityPartition46 = UML.createActivityPartition();
		assertValid(activityPartition46);
		activityPartition45.setRepresents(activityPartition46);

		ActivityPartition activityPartition47 = UML.createActivityPartition();
		assertValid(activityPartition47);

		Manifestation manifestation = UML.createManifestation();
		assertValid(manifestation);
		activityPartition47.setRepresents(manifestation);

		Interaction interaction = UML.createInteraction();
		assertValid(interaction);
		activityPartition47.setRepresents(interaction);

		ActivityPartition activityPartition48 = UML.createActivityPartition();
		assertValid(activityPartition48);

		ExceptionHandler exceptionHandler = UML.createExceptionHandler();
		assertValid(exceptionHandler);
		activityPartition48.setRepresents(exceptionHandler);

		OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior();
		assertValid(opaqueBehavior);
		activityPartition48.setRepresents(opaqueBehavior);

		ActivityPartition activityPartition49 = UML.createActivityPartition();
		assertValid(activityPartition49);

		LiteralUnlimitedNatural literalUnlimitedNatural = UML
			.createLiteralUnlimitedNatural();
		assertValid(literalUnlimitedNatural);
		activityPartition49.setRepresents(literalUnlimitedNatural);

		SendSignalAction sendSignalAction = UML.createSendSignalAction();
		assertValid(sendSignalAction);
		activityPartition49.setRepresents(sendSignalAction);

		ActivityPartition activityPartition50 = UML.createActivityPartition();
		assertValid(activityPartition50);

		Operation operation = UML.createOperation();
		assertValid(operation);
		activityPartition50.setRepresents(operation);

		ClearAssociationAction clearAssociationAction = UML
			.createClearAssociationAction();
		assertValid(clearAssociationAction);
		activityPartition50.setRepresents(clearAssociationAction);

		ActivityPartition activityPartition51 = UML.createActivityPartition();
		assertValid(activityPartition51);

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

		InstanceValue instanceValue = UML.createInstanceValue();
		assertValid(instanceValue);
		activityPartition51.setRepresents(instanceValue);

		ActivityPartition activityPartition52 = UML.createActivityPartition();
		assertValid(activityPartition52);

		InteractionConstraint interactionConstraint = UML
			.createInteractionConstraint();
		assertValid(interactionConstraint);
		activityPartition52.setRepresents(interactionConstraint);

		InteractionUse interactionUse = UML.createInteractionUse();
		assertValid(interactionUse);
		activityPartition52.setRepresents(interactionUse);

		ActivityPartition activityPartition53 = UML.createActivityPartition();
		assertValid(activityPartition53);

		Interval interval = UML.createInterval();
		assertValid(interval);
		activityPartition53.setRepresents(interval);

		LiteralString literalString = UML.createLiteralString();
		assertValid(literalString);
		activityPartition53.setRepresents(literalString);

		ActivityPartition activityPartition54 = UML.createActivityPartition();
		assertValid(activityPartition54);

		ValuePin valuePin = UML.createValuePin();
		assertValid(valuePin);
		activityPartition54.setRepresents(valuePin);

		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);
		activityPartition54.setRepresents(interfaceRealization);

		ActivityPartition activityPartition55 = UML.createActivityPartition();
		assertValid(activityPartition55);

		DecisionNode decisionNode = UML.createDecisionNode();
		assertValid(decisionNode);
		activityPartition55.setRepresents(decisionNode);

		Actor actor = UML.createActor();
		assertValid(actor);
		activityPartition55.setRepresents(actor);

		ActivityPartition activityPartition56 = UML.createActivityPartition();
		assertValid(activityPartition56);

		Generalization generalization = UML.createGeneralization();
		assertValid(generalization);
		activityPartition56.setRepresents(generalization);

		Reception reception = UML.createReception();
		assertValid(reception);
		activityPartition56.setRepresents(reception);

		ActivityPartition activityPartition57 = UML.createActivityPartition();
		assertValid(activityPartition57);

		Pseudostate pseudostate = UML.createPseudostate();
		assertValid(pseudostate);
		activityPartition57.setRepresents(pseudostate);

		DurationInterval durationInterval = UML.createDurationInterval();
		assertValid(durationInterval);
		activityPartition57.setRepresents(durationInterval);

		ActivityPartition activityPartition58 = UML.createActivityPartition();
		assertValid(activityPartition58);

		Deployment deployment = UML.createDeployment();
		assertValid(deployment);
		activityPartition58.setRepresents(deployment);

		QualifierValue qualifierValue = UML.createQualifierValue();
		assertValid(qualifierValue);
		activityPartition58.setRepresents(qualifierValue);

		ActivityPartition activityPartition59 = UML.createActivityPartition();
		assertValid(activityPartition59);

		PackageMerge packageMerge = UML.createPackageMerge();
		assertValid(packageMerge);
		activityPartition59.setRepresents(packageMerge);

		ConditionalNode conditionalNode = UML.createConditionalNode();
		assertValid(conditionalNode);
		activityPartition59.setRepresents(conditionalNode);

		ActivityPartition activityPartition60 = UML.createActivityPartition();
		assertValid(activityPartition60);

		SignalEvent signalEvent = UML.createSignalEvent();
		assertValid(signalEvent);
		activityPartition60.setRepresents(signalEvent);

		TemplateParameterSubstitution templateParameterSubstitution = UML
			.createTemplateParameterSubstitution();
		assertValid(templateParameterSubstitution);
		activityPartition60.setRepresents(templateParameterSubstitution);

		ActivityPartition activityPartition61 = UML.createActivityPartition();
		assertValid(activityPartition61);

		ConnectionPointReference connectionPointReference = UML
			.createConnectionPointReference();
		assertValid(connectionPointReference);
		activityPartition61.setRepresents(connectionPointReference);

		ReclassifyObjectAction reclassifyObjectAction = UML
			.createReclassifyObjectAction();
		assertValid(reclassifyObjectAction);
		activityPartition61.setRepresents(reclassifyObjectAction);

		ActivityPartition activityPartition62 = UML.createActivityPartition();
		assertValid(activityPartition62);

		Usage usage = UML.createUsage();
		assertValid(usage);
		activityPartition62.setRepresents(usage);

		DataStoreNode dataStoreNode = UML.createDataStoreNode();
		assertValid(dataStoreNode);
		activityPartition62.setRepresents(dataStoreNode);

		ActivityPartition activityPartition63 = UML.createActivityPartition();
		assertValid(activityPartition63);

		ExecutionEnvironment executionEnvironment = UML
			.createExecutionEnvironment();
		assertValid(executionEnvironment);
		activityPartition63.setRepresents(executionEnvironment);

		Realization realization = UML.createRealization();
		assertValid(realization);
		activityPartition63.setRepresents(realization);

		ActivityPartition activityPartition64 = UML.createActivityPartition();
		assertValid(activityPartition64);

		TestIdentityAction testIdentityAction = UML.createTestIdentityAction();
		assertValid(testIdentityAction);
		activityPartition64.setRepresents(testIdentityAction);

		Association association = UML.createAssociation();
		assertValid(association);
		activityPartition64.setRepresents(association);

		ActivityPartition activityPartition65 = UML.createActivityPartition();
		assertValid(activityPartition65);

		OutputPin outputPin = UML.createOutputPin();
		assertValid(outputPin);
		activityPartition65.setRepresents(outputPin);

		Include include = UML.createInclude();
		assertValid(include);
		activityPartition65.setRepresents(include);

		ActivityPartition activityPartition66 = UML.createActivityPartition();
		assertValid(activityPartition66);

		Extend extend = UML.createExtend();
		assertValid(extend);
		activityPartition66.setRepresents(extend);

		BroadcastSignalAction broadcastSignalAction = UML
			.createBroadcastSignalAction();
		assertValid(broadcastSignalAction);
		activityPartition66.setRepresents(broadcastSignalAction);

		ActivityPartition activityPartition67 = UML.createActivityPartition();
		assertValid(activityPartition67);

		FinalState finalState = UML.createFinalState();
		assertValid(finalState);
		activityPartition67.setRepresents(finalState);

		RaiseExceptionAction raiseExceptionAction = UML
			.createRaiseExceptionAction();
		assertValid(raiseExceptionAction);
		activityPartition67.setRepresents(raiseExceptionAction);

		ActivityPartition activityPartition68 = UML.createActivityPartition();
		assertValid(activityPartition68);

		ActivityFinalNode activityFinalNode = UML.createActivityFinalNode();
		assertValid(activityFinalNode);
		activityPartition68.setRepresents(activityFinalNode);

		ProtocolStateMachine protocolStateMachine = UML
			.createProtocolStateMachine();
		assertValid(protocolStateMachine);
		activityPartition68.setRepresents(protocolStateMachine);

		ActivityPartition activityPartition69 = UML.createActivityPartition();
		assertValid(activityPartition69);

		LoopNode loopNode = UML.createLoopNode();
		assertValid(loopNode);
		activityPartition69.setRepresents(loopNode);

		ParameterSet parameterSet = UML.createParameterSet();
		assertValid(parameterSet);
		activityPartition69.setRepresents(parameterSet);

		ActivityPartition activityPartition70 = UML.createActivityPartition();
		assertValid(activityPartition70);

		ValueSpecificationAction valueSpecificationAction = UML
			.createValueSpecificationAction();
		assertValid(valueSpecificationAction);
		activityPartition70.setRepresents(valueSpecificationAction);

		SequenceNode sequenceNode = UML.createSequenceNode();
		assertValid(sequenceNode);
		activityPartition70.setRepresents(sequenceNode);

		ActivityPartition activityPartition71 = UML.createActivityPartition();
		assertValid(activityPartition71);

		DestroyObjectAction destroyObjectAction = UML
			.createDestroyObjectAction();
		assertValid(destroyObjectAction);
		activityPartition71.setRepresents(destroyObjectAction);

		EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral();
		assertValid(enumerationLiteral);
		activityPartition71.setRepresents(enumerationLiteral);

		ActivityPartition activityPartition72 = UML.createActivityPartition();
		assertValid(activityPartition72);

		ActionExecutionSpecification actionExecutionSpecification = UML
			.createActionExecutionSpecification();
		assertValid(actionExecutionSpecification);
		activityPartition72.setRepresents(actionExecutionSpecification);

		FunctionBehavior functionBehavior = UML.createFunctionBehavior();
		assertValid(functionBehavior);
		activityPartition72.setRepresents(functionBehavior);

		ActivityPartition activityPartition73 = UML.createActivityPartition();
		assertValid(activityPartition73);

		InstanceSpecification instanceSpecification = UML
			.createInstanceSpecification();
		assertValid(instanceSpecification);
		activityPartition73.setRepresents(instanceSpecification);

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

		ActivityPartition activityPartition74 = UML.createActivityPartition();
		assertValid(activityPartition74);

		InformationItem informationItem = UML.createInformationItem();
		assertValid(informationItem);
		activityPartition74.setRepresents(informationItem);

		LiteralReal literalReal = UML.createLiteralReal();
		assertValid(literalReal);
		activityPartition74.setRepresents(literalReal);

		ActivityPartition activityPartition75 = UML.createActivityPartition();
		assertValid(activityPartition75);

		Duration duration = UML.createDuration();
		assertValid(duration);
		activityPartition75.setRepresents(duration);

		org.eclipse.uml2.uml.Package package_ = UML.createPackage();
		assertValid(package_);
		activityPartition75.setRepresents(package_);

		ActivityPartition activityPartition76 = UML.createActivityPartition();
		assertValid(activityPartition76);

		DestructionOccurrenceSpecification destructionOccurrenceSpecification = UML
			.createDestructionOccurrenceSpecification();
		assertValid(destructionOccurrenceSpecification);
		activityPartition76.setRepresents(destructionOccurrenceSpecification);

		Lifeline lifeline = UML.createLifeline();
		assertValid(lifeline);
		activityPartition76.setRepresents(lifeline);

		ActivityPartition activityPartition77 = UML.createActivityPartition();
		assertValid(activityPartition77);

		ProfileApplication profileApplication = UML.createProfileApplication();
		assertValid(profileApplication);
		activityPartition77.setRepresents(profileApplication);

		TimeObservation timeObservation = UML.createTimeObservation();
		assertValid(timeObservation);
		activityPartition77.setRepresents(timeObservation);

		ActivityPartition activityPartition78 = UML.createActivityPartition();
		assertValid(activityPartition78);

		ReplyAction replyAction = UML.createReplyAction();
		assertValid(replyAction);
		activityPartition78.setRepresents(replyAction);

		Gate gate = UML.createGate();
		assertValid(gate);
		activityPartition78.setRepresents(gate);

		ActivityPartition activityPartition79 = UML.createActivityPartition();
		assertValid(activityPartition79);

		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);
		activityPartition79.setRepresents(timeExpression);

		Device device = UML.createDevice();
		assertValid(device);
		activityPartition79.setRepresents(device);

		ActivityPartition activityPartition80 = UML.createActivityPartition();
		assertValid(activityPartition80);

		FlowFinalNode flowFinalNode = UML.createFlowFinalNode();
		assertValid(flowFinalNode);
		activityPartition80.setRepresents(flowFinalNode);

		Abstraction abstraction = UML.createAbstraction();
		assertValid(abstraction);
		activityPartition80.setRepresents(abstraction);

		ActivityPartition activityPartition81 = UML.createActivityPartition();
		assertValid(activityPartition81);

		Enumeration enumeration = UML.createEnumeration();
		assertValid(enumeration);
		activityPartition81.setRepresents(enumeration);

		PrimitiveType primitiveType = UML.createPrimitiveType();
		assertValid(primitiveType);
		activityPartition81.setRepresents(primitiveType);

		ActivityPartition activityPartition82 = UML.createActivityPartition();
		assertValid(activityPartition82);

		LinkEndDestructionData linkEndDestructionData = UML
			.createLinkEndDestructionData();
		assertValid(linkEndDestructionData);
		activityPartition82.setRepresents(linkEndDestructionData);

		GeneralizationSet generalizationSet = UML.createGeneralizationSet();
		assertValid(generalizationSet);
		activityPartition82.setRepresents(generalizationSet);

		ActivityPartition activityPartition83 = UML.createActivityPartition();
		assertValid(activityPartition83);

		Signal signal = UML.createSignal();
		assertValid(signal);
		activityPartition83.setRepresents(signal);

		CallBehaviorAction callBehaviorAction = UML.createCallBehaviorAction();
		assertValid(callBehaviorAction);
		activityPartition83.setRepresents(callBehaviorAction);

		ActivityPartition activityPartition84 = UML.createActivityPartition();
		assertValid(activityPartition84);

		Clause clause = UML.createClause();
		assertValid(clause);
		activityPartition84.setRepresents(clause);

		ReadIsClassifiedObjectAction readIsClassifiedObjectAction = UML
			.createReadIsClassifiedObjectAction();
		assertValid(readIsClassifiedObjectAction);
		activityPartition84.setRepresents(readIsClassifiedObjectAction);

		ActivityPartition activityPartition85 = UML.createActivityPartition();
		assertValid(activityPartition85);

		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);
		activityPartition85.setRepresents(activityParameterNode);

		ReadVariableAction readVariableAction = UML.createReadVariableAction();
		assertValid(readVariableAction);
		activityPartition85.setRepresents(readVariableAction);

		ActivityPartition activityPartition86 = UML.createActivityPartition();
		assertValid(activityPartition86);

		InterruptibleActivityRegion interruptibleActivityRegion = UML
			.createInterruptibleActivityRegion();
		assertValid(interruptibleActivityRegion);
		activityPartition86.setRepresents(interruptibleActivityRegion);

		RemoveStructuralFeatureValueAction removeStructuralFeatureValueAction = UML
			.createRemoveStructuralFeatureValueAction();
		assertValid(removeStructuralFeatureValueAction);
		activityPartition86.setRepresents(removeStructuralFeatureValueAction);

		ActivityPartition activityPartition87 = UML.createActivityPartition();
		assertValid(activityPartition87);

		Region region = UML.createRegion();
		assertValid(region);
		activityPartition87.setRepresents(region);

		Transition transition = UML.createTransition();
		assertValid(transition);
		activityPartition87.setRepresents(transition);

		ActivityPartition activityPartition88 = UML.createActivityPartition();
		assertValid(activityPartition88);

		AnyReceiveEvent anyReceiveEvent = UML.createAnyReceiveEvent();
		assertValid(anyReceiveEvent);
		activityPartition88.setRepresents(anyReceiveEvent);

		ReduceAction reduceAction = UML.createReduceAction();
		assertValid(reduceAction);
		activityPartition88.setRepresents(reduceAction);

		ActivityPartition activityPartition89 = UML.createActivityPartition();
		assertValid(activityPartition89);

		AcceptEventAction acceptEventAction = UML.createAcceptEventAction();
		assertValid(acceptEventAction);
		activityPartition89.setRepresents(acceptEventAction);

		InitialNode initialNode = UML.createInitialNode();
		assertValid(initialNode);
		activityPartition89.setRepresents(initialNode);

		ActivityPartition activityPartition90 = UML.createActivityPartition();
		assertValid(activityPartition90);

		CombinedFragment combinedFragment = UML.createCombinedFragment();
		assertValid(combinedFragment);
		activityPartition90.setRepresents(combinedFragment);

		IntervalConstraint intervalConstraint = UML.createIntervalConstraint();
		assertValid(intervalConstraint);
		activityPartition90.setRepresents(intervalConstraint);

		ActivityPartition activityPartition91 = UML.createActivityPartition();
		assertValid(activityPartition91);

		OccurrenceSpecification occurrenceSpecification = UML
			.createOccurrenceSpecification();
		assertValid(occurrenceSpecification);
		activityPartition91.setRepresents(occurrenceSpecification);

		Connector connector = UML.createConnector();
		assertValid(connector);
		activityPartition91.setRepresents(connector);

		ActivityPartition activityPartition92 = UML.createActivityPartition();
		assertValid(activityPartition92);

		ComponentRealization componentRealization = UML
			.createComponentRealization();
		assertValid(componentRealization);
		activityPartition92.setRepresents(componentRealization);

		org.eclipse.uml2.uml.Class class_ = UML.createClass();
		assertValid(class_);
		activityPartition92.setRepresents(class_);

		ActivityPartition activityPartition93 = UML.createActivityPartition();
		assertValid(activityPartition93);

		State state = UML.createState();
		assertValid(state);
		activityPartition93.setRepresents(state);

		ProtocolTransition protocolTransition = UML.createProtocolTransition();
		assertValid(protocolTransition);
		activityPartition93.setRepresents(protocolTransition);

		ActivityPartition activityPartition94 = UML.createActivityPartition();
		assertValid(activityPartition94);

		OperationTemplateParameter operationTemplateParameter = UML
			.createOperationTemplateParameter();
		assertValid(operationTemplateParameter);
		activityPartition94.setRepresents(operationTemplateParameter);

		CollaborationUse collaborationUse = UML.createCollaborationUse();
		assertValid(collaborationUse);
		activityPartition94.setRepresents(collaborationUse);

		ActivityPartition activityPartition95 = UML.createActivityPartition();
		assertValid(activityPartition95);

		InteractionOperand interactionOperand = UML.createInteractionOperand();
		assertValid(interactionOperand);
		activityPartition95.setRepresents(interactionOperand);

		AddVariableValueAction addVariableValueAction = UML
			.createAddVariableValueAction();
		assertValid(addVariableValueAction);
		activityPartition95.setRepresents(addVariableValueAction);

		ActivityPartition activityPartition96 = UML.createActivityPartition();
		assertValid(activityPartition96);

		UseCase useCase = UML.createUseCase();
		assertValid(useCase);
		activityPartition96.setRepresents(useCase);

		UnmarshallAction unmarshallAction = UML.createUnmarshallAction();
		assertValid(unmarshallAction);
		activityPartition96.setRepresents(unmarshallAction);

		ActivityPartition activityPartition97 = UML.createActivityPartition();
		assertValid(activityPartition97);

		CreateObjectAction createObjectAction = UML.createCreateObjectAction();
		assertValid(createObjectAction);
		activityPartition97.setRepresents(createObjectAction);

		ReadStructuralFeatureAction readStructuralFeatureAction = UML
			.createReadStructuralFeatureAction();
		assertValid(readStructuralFeatureAction);
		activityPartition97.setRepresents(readStructuralFeatureAction);

		ActivityPartition activityPartition98 = UML.createActivityPartition();
		assertValid(activityPartition98);

		Collaboration collaboration = UML.createCollaboration();
		assertValid(collaboration);
		activityPartition98.setRepresents(collaboration);
	}

	public void testSubpartition() {
		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);

		ActivityPartition activityPartition2 = UML.createActivityPartition();
		assertValid(activityPartition2);
		activityPartition.getSubpartitions().add(activityPartition2);
		assertSuperset(
			activityPartition.getSubgroups().contains(activityPartition2));
	}

	public void testSuperPartition() {
		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);

		ActivityPartition activityPartition2 = UML.createActivityPartition();
		assertValid(activityPartition2);
		activityPartition.setSuperPartition(activityPartition2);
		assertSuperset(activityPartition.getSuperGroup() == activityPartition2);
	}

	public void testEdge() {
		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);

		ControlFlow controlFlow = UML.createControlFlow();
		assertValid(controlFlow);
		activityPartition.getEdges().add(controlFlow);
		assertSuperset(
			activityPartition.getContainedEdges().contains(controlFlow));

		ObjectFlow objectFlow = UML.createObjectFlow();
		assertValid(objectFlow);
		activityPartition.getEdges().add(objectFlow);
		assertSuperset(
			activityPartition.getContainedEdges().contains(objectFlow));
	}

}