/*
 * 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.AcceptCallAction;
import org.eclipse.uml2.uml.AcceptEventAction;
import org.eclipse.uml2.uml.ActionInputPin;
import org.eclipse.uml2.uml.Activity;
import org.eclipse.uml2.uml.ActivityFinalNode;
import org.eclipse.uml2.uml.ActivityGroup;
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.Artifact;
import org.eclipse.uml2.uml.Association;
import org.eclipse.uml2.uml.AssociationClass;
import org.eclipse.uml2.uml.BroadcastSignalAction;
import org.eclipse.uml2.uml.CallBehaviorAction;
import org.eclipse.uml2.uml.CallOperationAction;
import org.eclipse.uml2.uml.CentralBufferNode;
import org.eclipse.uml2.uml.Classifier;
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.Comment;
import org.eclipse.uml2.uml.CommunicationPath;
import org.eclipse.uml2.uml.Component;
import org.eclipse.uml2.uml.ConditionalNode;
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.DeploymentSpecification;
import org.eclipse.uml2.uml.DestroyLinkAction;
import org.eclipse.uml2.uml.DestroyObjectAction;
import org.eclipse.uml2.uml.Device;
import org.eclipse.uml2.uml.Duration;
import org.eclipse.uml2.uml.DurationInterval;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.Enumeration;
import org.eclipse.uml2.uml.ExecutionEnvironment;
import org.eclipse.uml2.uml.ExpansionNode;
import org.eclipse.uml2.uml.ExpansionRegion;
import org.eclipse.uml2.uml.Expression;
import org.eclipse.uml2.uml.Extension;
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.InformationItem;
import org.eclipse.uml2.uml.InitialNode;
import org.eclipse.uml2.uml.InputPin;
import org.eclipse.uml2.uml.InstanceValue;
import org.eclipse.uml2.uml.Interaction;
import org.eclipse.uml2.uml.Interface;
import org.eclipse.uml2.uml.InterruptibleActivityRegion;
import org.eclipse.uml2.uml.Interval;
import org.eclipse.uml2.uml.JoinNode;
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.MergeNode;
import org.eclipse.uml2.uml.Node;
import org.eclipse.uml2.uml.ObjectFlow;
import org.eclipse.uml2.uml.OpaqueAction;
import org.eclipse.uml2.uml.OpaqueBehavior;
import org.eclipse.uml2.uml.OpaqueExpression;
import org.eclipse.uml2.uml.OutputPin;
import org.eclipse.uml2.uml.Parameter;
import org.eclipse.uml2.uml.PrimitiveType;
import org.eclipse.uml2.uml.ProtocolStateMachine;
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.ReclassifyObjectAction;
import org.eclipse.uml2.uml.RedefinableElement;
import org.eclipse.uml2.uml.ReduceAction;
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.StartClassifierBehaviorAction;
import org.eclipse.uml2.uml.StartObjectBehaviorAction;
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.StructuredActivityNode;
import org.eclipse.uml2.uml.TestIdentityAction;
import org.eclipse.uml2.uml.TimeExpression;
import org.eclipse.uml2.uml.TimeInterval;
import org.eclipse.uml2.uml.UnmarshallAction;
import org.eclipse.uml2.uml.UseCase;
import org.eclipse.uml2.uml.ValuePin;
import org.eclipse.uml2.uml.ValueSpecificationAction;

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

	public void testEAnnotations() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);

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

	public void testOwnedComment() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);

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

	public void testOwnedElement() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);
		EList<Element> elements = activityParameterNode.getOwnedElements();
		EList<Element> elements2 = activityParameterNode.getOwnedElements();
		assertSame(elements, elements2);
	}

	public void testClientDependency() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);
		EList<Dependency> dependencys = activityParameterNode
			.getClientDependencies();
		EList<Dependency> dependencys2 = activityParameterNode
			.getClientDependencies();
		assertSame(dependencys, dependencys2);
	}

	public void testNameExpression() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);

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

	public void testRedefinedElement() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);
		EList<RedefinableElement> redefinableElements = activityParameterNode
			.getRedefinedElements();
		EList<RedefinableElement> redefinableElements2 = activityParameterNode
			.getRedefinedElements();
		assertSame(redefinableElements, redefinableElements2);
	}

	public void testRedefinitionContext() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);
		EList<Classifier> classifiers = activityParameterNode
			.getRedefinitionContexts();
		EList<Classifier> classifiers2 = activityParameterNode
			.getRedefinitionContexts();
		assertSame(classifiers, classifiers2);
	}

	public void testInGroup() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);
		EList<ActivityGroup> activityGroups = activityParameterNode
			.getInGroups();
		EList<ActivityGroup> activityGroups2 = activityParameterNode
			.getInGroups();
		assertSame(activityGroups, activityGroups2);
	}

	public void testInInterruptibleRegion() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);

		InterruptibleActivityRegion interruptibleActivityRegion = UML
			.createInterruptibleActivityRegion();
		assertValid(interruptibleActivityRegion);
		activityParameterNode.getInInterruptibleRegions()
			.add(interruptibleActivityRegion);
		assertSuperset(activityParameterNode.getInGroups()
			.contains(interruptibleActivityRegion));
	}

	public void testInStructuredNode() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);

		LoopNode loopNode = UML.createLoopNode();
		assertValid(loopNode);
		activityParameterNode.setInStructuredNode(loopNode);
		assertSuperset(activityParameterNode.getInGroups().contains(loopNode));
		assertSuperset(activityParameterNode.getOwner() == loopNode);

		ExpansionRegion expansionRegion = UML.createExpansionRegion();
		assertValid(expansionRegion);
		activityParameterNode.setInStructuredNode(expansionRegion);
		assertSuperset(
			activityParameterNode.getInGroups().contains(expansionRegion));
		assertSuperset(activityParameterNode.getOwner() == expansionRegion);

		ActivityParameterNode activityParameterNode2 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode2);

		StructuredActivityNode structuredActivityNode = UML
			.createStructuredActivityNode();
		assertValid(structuredActivityNode);
		activityParameterNode2.setInStructuredNode(structuredActivityNode);
		assertSuperset(activityParameterNode2.getInGroups()
			.contains(structuredActivityNode));
		assertSuperset(
			activityParameterNode2.getOwner() == structuredActivityNode);

		ConditionalNode conditionalNode = UML.createConditionalNode();
		assertValid(conditionalNode);
		activityParameterNode2.setInStructuredNode(conditionalNode);
		assertSuperset(
			activityParameterNode2.getInGroups().contains(conditionalNode));
		assertSuperset(activityParameterNode2.getOwner() == conditionalNode);
	}

	public void testIncoming() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);

		ControlFlow controlFlow = UML.createControlFlow();
		assertValid(controlFlow);
		activityParameterNode.getIncomings().add(controlFlow);

		ObjectFlow objectFlow = UML.createObjectFlow();
		assertValid(objectFlow);
		activityParameterNode.getIncomings().add(objectFlow);
	}

	public void testOutgoing() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);

		ControlFlow controlFlow = UML.createControlFlow();
		assertValid(controlFlow);
		activityParameterNode.getOutgoings().add(controlFlow);

		ObjectFlow objectFlow = UML.createObjectFlow();
		assertValid(objectFlow);
		activityParameterNode.getOutgoings().add(objectFlow);
	}

	public void testRedefinedNode() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);

		StartClassifierBehaviorAction startClassifierBehaviorAction = UML
			.createStartClassifierBehaviorAction();
		assertValid(startClassifierBehaviorAction);
		activityParameterNode.getRedefinedNodes()
			.add(startClassifierBehaviorAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(startClassifierBehaviorAction));

		RemoveVariableValueAction removeVariableValueAction = UML
			.createRemoveVariableValueAction();
		assertValid(removeVariableValueAction);
		activityParameterNode.getRedefinedNodes()
			.add(removeVariableValueAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(removeVariableValueAction));

		ReadSelfAction readSelfAction = UML.createReadSelfAction();
		assertValid(readSelfAction);
		activityParameterNode.getRedefinedNodes().add(readSelfAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(readSelfAction));

		InputPin inputPin = UML.createInputPin();
		assertValid(inputPin);
		activityParameterNode.getRedefinedNodes().add(inputPin);
		assertSuperset(
			activityParameterNode.getRedefinedElements().contains(inputPin));

		ReadLinkObjectEndQualifierAction readLinkObjectEndQualifierAction = UML
			.createReadLinkObjectEndQualifierAction();
		assertValid(readLinkObjectEndQualifierAction);
		activityParameterNode.getRedefinedNodes()
			.add(readLinkObjectEndQualifierAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(readLinkObjectEndQualifierAction));

		JoinNode joinNode = UML.createJoinNode();
		assertValid(joinNode);
		activityParameterNode.getRedefinedNodes().add(joinNode);
		assertSuperset(
			activityParameterNode.getRedefinedElements().contains(joinNode));

		CreateLinkObjectAction createLinkObjectAction = UML
			.createCreateLinkObjectAction();
		assertValid(createLinkObjectAction);
		activityParameterNode.getRedefinedNodes().add(createLinkObjectAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(createLinkObjectAction));

		SendSignalAction sendSignalAction = UML.createSendSignalAction();
		assertValid(sendSignalAction);
		activityParameterNode.getRedefinedNodes().add(sendSignalAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(sendSignalAction));

		ReadLinkAction readLinkAction = UML.createReadLinkAction();
		assertValid(readLinkAction);
		activityParameterNode.getRedefinedNodes().add(readLinkAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(readLinkAction));

		ReplyAction replyAction = UML.createReplyAction();
		assertValid(replyAction);
		activityParameterNode.getRedefinedNodes().add(replyAction);
		assertSuperset(
			activityParameterNode.getRedefinedElements().contains(replyAction));

		ClearAssociationAction clearAssociationAction = UML
			.createClearAssociationAction();
		assertValid(clearAssociationAction);
		activityParameterNode.getRedefinedNodes().add(clearAssociationAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(clearAssociationAction));

		FlowFinalNode flowFinalNode = UML.createFlowFinalNode();
		assertValid(flowFinalNode);
		activityParameterNode.getRedefinedNodes().add(flowFinalNode);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(flowFinalNode));

		ClearStructuralFeatureAction clearStructuralFeatureAction = UML
			.createClearStructuralFeatureAction();
		assertValid(clearStructuralFeatureAction);
		activityParameterNode.getRedefinedNodes()
			.add(clearStructuralFeatureAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(clearStructuralFeatureAction));

		ExpansionRegion expansionRegion = UML.createExpansionRegion();
		assertValid(expansionRegion);
		activityParameterNode.getRedefinedNodes().add(expansionRegion);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(expansionRegion));

		StructuredActivityNode structuredActivityNode = UML
			.createStructuredActivityNode();
		assertValid(structuredActivityNode);
		activityParameterNode.getRedefinedNodes().add(structuredActivityNode);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(structuredActivityNode));

		ValuePin valuePin = UML.createValuePin();
		assertValid(valuePin);
		activityParameterNode.getRedefinedNodes().add(valuePin);
		assertSuperset(
			activityParameterNode.getRedefinedElements().contains(valuePin));

		StartObjectBehaviorAction startObjectBehaviorAction = UML
			.createStartObjectBehaviorAction();
		assertValid(startObjectBehaviorAction);
		activityParameterNode.getRedefinedNodes()
			.add(startObjectBehaviorAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(startObjectBehaviorAction));

		ForkNode forkNode = UML.createForkNode();
		assertValid(forkNode);
		activityParameterNode.getRedefinedNodes().add(forkNode);
		assertSuperset(
			activityParameterNode.getRedefinedElements().contains(forkNode));

		DecisionNode decisionNode = UML.createDecisionNode();
		assertValid(decisionNode);
		activityParameterNode.getRedefinedNodes().add(decisionNode);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(decisionNode));

		CallBehaviorAction callBehaviorAction = UML.createCallBehaviorAction();
		assertValid(callBehaviorAction);
		activityParameterNode.getRedefinedNodes().add(callBehaviorAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(callBehaviorAction));

		ConditionalNode conditionalNode = UML.createConditionalNode();
		assertValid(conditionalNode);
		activityParameterNode.getRedefinedNodes().add(conditionalNode);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(conditionalNode));

		ReadExtentAction readExtentAction = UML.createReadExtentAction();
		assertValid(readExtentAction);
		activityParameterNode.getRedefinedNodes().add(readExtentAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(readExtentAction));

		ActionInputPin actionInputPin = UML.createActionInputPin();
		assertValid(actionInputPin);
		activityParameterNode.getRedefinedNodes().add(actionInputPin);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(actionInputPin));

		ReadIsClassifiedObjectAction readIsClassifiedObjectAction = UML
			.createReadIsClassifiedObjectAction();
		assertValid(readIsClassifiedObjectAction);
		activityParameterNode.getRedefinedNodes()
			.add(readIsClassifiedObjectAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(readIsClassifiedObjectAction));

		ActivityParameterNode activityParameterNode2 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode2);
		activityParameterNode.getRedefinedNodes().add(activityParameterNode2);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(activityParameterNode2));

		AddStructuralFeatureValueAction addStructuralFeatureValueAction = UML
			.createAddStructuralFeatureValueAction();
		assertValid(addStructuralFeatureValueAction);
		activityParameterNode.getRedefinedNodes()
			.add(addStructuralFeatureValueAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(addStructuralFeatureValueAction));

		ReadVariableAction readVariableAction = UML.createReadVariableAction();
		assertValid(readVariableAction);
		activityParameterNode.getRedefinedNodes().add(readVariableAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(readVariableAction));

		ClearVariableAction clearVariableAction = UML
			.createClearVariableAction();
		assertValid(clearVariableAction);
		activityParameterNode.getRedefinedNodes().add(clearVariableAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(clearVariableAction));

		RemoveStructuralFeatureValueAction removeStructuralFeatureValueAction = UML
			.createRemoveStructuralFeatureValueAction();
		assertValid(removeStructuralFeatureValueAction);
		activityParameterNode.getRedefinedNodes()
			.add(removeStructuralFeatureValueAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(removeStructuralFeatureValueAction));

		CreateLinkAction createLinkAction = UML.createCreateLinkAction();
		assertValid(createLinkAction);
		activityParameterNode.getRedefinedNodes().add(createLinkAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(createLinkAction));

		ReclassifyObjectAction reclassifyObjectAction = UML
			.createReclassifyObjectAction();
		assertValid(reclassifyObjectAction);
		activityParameterNode.getRedefinedNodes().add(reclassifyObjectAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(reclassifyObjectAction));

		DataStoreNode dataStoreNode = UML.createDataStoreNode();
		assertValid(dataStoreNode);
		activityParameterNode.getRedefinedNodes().add(dataStoreNode);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(dataStoreNode));

		SendObjectAction sendObjectAction = UML.createSendObjectAction();
		assertValid(sendObjectAction);
		activityParameterNode.getRedefinedNodes().add(sendObjectAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(sendObjectAction));

		ReduceAction reduceAction = UML.createReduceAction();
		assertValid(reduceAction);
		activityParameterNode.getRedefinedNodes().add(reduceAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(reduceAction));

		AcceptEventAction acceptEventAction = UML.createAcceptEventAction();
		assertValid(acceptEventAction);
		activityParameterNode.getRedefinedNodes().add(acceptEventAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(acceptEventAction));

		DestroyLinkAction destroyLinkAction = UML.createDestroyLinkAction();
		assertValid(destroyLinkAction);
		activityParameterNode.getRedefinedNodes().add(destroyLinkAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(destroyLinkAction));

		ExpansionNode expansionNode = UML.createExpansionNode();
		assertValid(expansionNode);
		activityParameterNode.getRedefinedNodes().add(expansionNode);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(expansionNode));

		InitialNode initialNode = UML.createInitialNode();
		assertValid(initialNode);
		activityParameterNode.getRedefinedNodes().add(initialNode);
		assertSuperset(
			activityParameterNode.getRedefinedElements().contains(initialNode));

		TestIdentityAction testIdentityAction = UML.createTestIdentityAction();
		assertValid(testIdentityAction);
		activityParameterNode.getRedefinedNodes().add(testIdentityAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(testIdentityAction));

		OutputPin outputPin = UML.createOutputPin();
		assertValid(outputPin);
		activityParameterNode.getRedefinedNodes().add(outputPin);
		assertSuperset(
			activityParameterNode.getRedefinedElements().contains(outputPin));

		CentralBufferNode centralBufferNode = UML.createCentralBufferNode();
		assertValid(centralBufferNode);
		activityParameterNode.getRedefinedNodes().add(centralBufferNode);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(centralBufferNode));

		BroadcastSignalAction broadcastSignalAction = UML
			.createBroadcastSignalAction();
		assertValid(broadcastSignalAction);
		activityParameterNode.getRedefinedNodes().add(broadcastSignalAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(broadcastSignalAction));

		RaiseExceptionAction raiseExceptionAction = UML
			.createRaiseExceptionAction();
		assertValid(raiseExceptionAction);
		activityParameterNode.getRedefinedNodes().add(raiseExceptionAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(raiseExceptionAction));

		ActivityFinalNode activityFinalNode = UML.createActivityFinalNode();
		assertValid(activityFinalNode);
		activityParameterNode.getRedefinedNodes().add(activityFinalNode);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(activityFinalNode));

		CallOperationAction callOperationAction = UML
			.createCallOperationAction();
		assertValid(callOperationAction);
		activityParameterNode.getRedefinedNodes().add(callOperationAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(callOperationAction));

		LoopNode loopNode = UML.createLoopNode();
		assertValid(loopNode);
		activityParameterNode.getRedefinedNodes().add(loopNode);
		assertSuperset(
			activityParameterNode.getRedefinedElements().contains(loopNode));

		ValueSpecificationAction valueSpecificationAction = UML
			.createValueSpecificationAction();
		assertValid(valueSpecificationAction);
		activityParameterNode.getRedefinedNodes().add(valueSpecificationAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(valueSpecificationAction));

		AcceptCallAction acceptCallAction = UML.createAcceptCallAction();
		assertValid(acceptCallAction);
		activityParameterNode.getRedefinedNodes().add(acceptCallAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(acceptCallAction));

		AddVariableValueAction addVariableValueAction = UML
			.createAddVariableValueAction();
		assertValid(addVariableValueAction);
		activityParameterNode.getRedefinedNodes().add(addVariableValueAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(addVariableValueAction));

		ReadLinkObjectEndAction readLinkObjectEndAction = UML
			.createReadLinkObjectEndAction();
		assertValid(readLinkObjectEndAction);
		activityParameterNode.getRedefinedNodes().add(readLinkObjectEndAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(readLinkObjectEndAction));

		UnmarshallAction unmarshallAction = UML.createUnmarshallAction();
		assertValid(unmarshallAction);
		activityParameterNode.getRedefinedNodes().add(unmarshallAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(unmarshallAction));

		OpaqueAction opaqueAction = UML.createOpaqueAction();
		assertValid(opaqueAction);
		activityParameterNode.getRedefinedNodes().add(opaqueAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(opaqueAction));

		MergeNode mergeNode = UML.createMergeNode();
		assertValid(mergeNode);
		activityParameterNode.getRedefinedNodes().add(mergeNode);
		assertSuperset(
			activityParameterNode.getRedefinedElements().contains(mergeNode));

		SequenceNode sequenceNode = UML.createSequenceNode();
		assertValid(sequenceNode);
		activityParameterNode.getRedefinedNodes().add(sequenceNode);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(sequenceNode));

		CreateObjectAction createObjectAction = UML.createCreateObjectAction();
		assertValid(createObjectAction);
		activityParameterNode.getRedefinedNodes().add(createObjectAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(createObjectAction));

		DestroyObjectAction destroyObjectAction = UML
			.createDestroyObjectAction();
		assertValid(destroyObjectAction);
		activityParameterNode.getRedefinedNodes().add(destroyObjectAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(destroyObjectAction));

		ReadStructuralFeatureAction readStructuralFeatureAction = UML
			.createReadStructuralFeatureAction();
		assertValid(readStructuralFeatureAction);
		activityParameterNode.getRedefinedNodes()
			.add(readStructuralFeatureAction);
		assertSuperset(activityParameterNode.getRedefinedElements()
			.contains(readStructuralFeatureAction));
	}

	public void testInPartition() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);

		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);
		activityParameterNode.getInPartitions().add(activityPartition);
		assertSuperset(
			activityParameterNode.getInGroups().contains(activityPartition));
	}

	public void testType() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);

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

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

		ActivityParameterNode activityParameterNode2 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode2);

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

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

		ActivityParameterNode activityParameterNode3 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode3);

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

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

		ActivityParameterNode activityParameterNode4 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode4);

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

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

		ActivityParameterNode activityParameterNode5 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode5);

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

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

		ActivityParameterNode activityParameterNode6 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode6);

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

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

		ActivityParameterNode activityParameterNode7 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode7);

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

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

		ActivityParameterNode activityParameterNode8 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode8);

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

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

		ActivityParameterNode activityParameterNode9 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode9);

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

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

		ActivityParameterNode activityParameterNode10 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode10);

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

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

		ActivityParameterNode activityParameterNode11 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode11);

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

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

		ActivityParameterNode activityParameterNode12 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode12);

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

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

		ActivityParameterNode activityParameterNode13 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode13);

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

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

		ActivityParameterNode activityParameterNode14 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode14);

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

	public void testInState() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);

		FinalState finalState = UML.createFinalState();
		assertValid(finalState);
		activityParameterNode.getInStates().add(finalState);

		State state = UML.createState();
		assertValid(state);
		activityParameterNode.getInStates().add(state);
	}

	public void testSelection() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);

		ProtocolStateMachine protocolStateMachine = UML
			.createProtocolStateMachine();
		assertValid(protocolStateMachine);
		activityParameterNode.setSelection(protocolStateMachine);

		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		activityParameterNode.setSelection(stateMachine);
	}

	public void testUpperBound() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);

		LiteralBoolean literalBoolean = UML.createLiteralBoolean();
		assertValid(literalBoolean);
		activityParameterNode.setUpperBound(literalBoolean);
		assertSuperset(
			activityParameterNode.getOwnedElements().contains(literalBoolean));

		Interval interval = UML.createInterval();
		assertValid(interval);
		activityParameterNode.setUpperBound(interval);
		assertSuperset(
			activityParameterNode.getOwnedElements().contains(interval));

		ActivityParameterNode activityParameterNode2 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode2);

		OpaqueExpression opaqueExpression = UML.createOpaqueExpression();
		assertValid(opaqueExpression);
		activityParameterNode2.setUpperBound(opaqueExpression);
		assertSuperset(activityParameterNode2.getOwnedElements()
			.contains(opaqueExpression));

		Expression expression = UML.createExpression();
		assertValid(expression);
		activityParameterNode2.setUpperBound(expression);
		assertSuperset(
			activityParameterNode2.getOwnedElements().contains(expression));

		ActivityParameterNode activityParameterNode3 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode3);

		LiteralReal literalReal = UML.createLiteralReal();
		assertValid(literalReal);
		activityParameterNode3.setUpperBound(literalReal);
		assertSuperset(
			activityParameterNode3.getOwnedElements().contains(literalReal));

		LiteralString literalString = UML.createLiteralString();
		assertValid(literalString);
		activityParameterNode3.setUpperBound(literalString);
		assertSuperset(
			activityParameterNode3.getOwnedElements().contains(literalString));

		ActivityParameterNode activityParameterNode4 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode4);

		LiteralNull literalNull = UML.createLiteralNull();
		assertValid(literalNull);
		activityParameterNode4.setUpperBound(literalNull);
		assertSuperset(
			activityParameterNode4.getOwnedElements().contains(literalNull));

		Duration duration = UML.createDuration();
		assertValid(duration);
		activityParameterNode4.setUpperBound(duration);
		assertSuperset(
			activityParameterNode4.getOwnedElements().contains(duration));

		ActivityParameterNode activityParameterNode5 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode5);

		LiteralInteger literalInteger = UML.createLiteralInteger();
		assertValid(literalInteger);
		activityParameterNode5.setUpperBound(literalInteger);
		assertSuperset(
			activityParameterNode5.getOwnedElements().contains(literalInteger));

		DurationInterval durationInterval = UML.createDurationInterval();
		assertValid(durationInterval);
		activityParameterNode5.setUpperBound(durationInterval);
		assertSuperset(activityParameterNode5.getOwnedElements()
			.contains(durationInterval));

		ActivityParameterNode activityParameterNode6 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode6);

		StringExpression stringExpression = UML.createStringExpression();
		assertValid(stringExpression);
		activityParameterNode6.setUpperBound(stringExpression);
		assertSuperset(activityParameterNode6.getOwnedElements()
			.contains(stringExpression));

		LiteralUnlimitedNatural literalUnlimitedNatural = UML
			.createLiteralUnlimitedNatural();
		assertValid(literalUnlimitedNatural);
		activityParameterNode6.setUpperBound(literalUnlimitedNatural);
		assertSuperset(activityParameterNode6.getOwnedElements()
			.contains(literalUnlimitedNatural));

		ActivityParameterNode activityParameterNode7 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode7);

		TimeInterval timeInterval = UML.createTimeInterval();
		assertValid(timeInterval);
		activityParameterNode7.setUpperBound(timeInterval);
		assertSuperset(
			activityParameterNode7.getOwnedElements().contains(timeInterval));

		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);
		activityParameterNode7.setUpperBound(timeExpression);
		assertSuperset(
			activityParameterNode7.getOwnedElements().contains(timeExpression));

		ActivityParameterNode activityParameterNode8 = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode8);

		InstanceValue instanceValue = UML.createInstanceValue();
		assertValid(instanceValue);
		activityParameterNode8.setUpperBound(instanceValue);
		assertSuperset(
			activityParameterNode8.getOwnedElements().contains(instanceValue));
	}

	public void testParameter() {
		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);

		Parameter parameter = UML.createParameter();
		assertValid(parameter);
		activityParameterNode.setParameter(parameter);
	}

}