/*
 * 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.ActivityFinalNode;
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.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.ConnectionPointReference;
import org.eclipse.uml2.uml.Connector;
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.Enumeration;
import org.eclipse.uml2.uml.EnumerationLiteral;
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.GeneralizationSet;
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.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.OutputPin;
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.Property;
import org.eclipse.uml2.uml.ProtocolStateMachine;
import org.eclipse.uml2.uml.ProtocolTransition;
import org.eclipse.uml2.uml.Pseudostate;
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.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.TemplateParameter;
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 InterfaceRealizationTest
		extends _Abstract_Compliance_Test_ {

	public void testEAnnotations() {
		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);

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

	public void testOwnedComment() {
		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);

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

	public void testOwnedElement() {
		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);
		EList<Element> elements = interfaceRealization.getOwnedElements();
		EList<Element> elements2 = interfaceRealization.getOwnedElements();
		assertSame(elements, elements2);
	}

	public void testClientDependency() {
		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);
		EList<Dependency> dependencys = interfaceRealization
			.getClientDependencies();
		EList<Dependency> dependencys2 = interfaceRealization
			.getClientDependencies();
		assertSame(dependencys, dependencys2);
	}

	public void testNameExpression() {
		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);

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

	public void testOwningTemplateParameter() {
		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);

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

	public void testTemplateParameter() {
		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);

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

	public void testRelatedElement() {
		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);
		EList<Element> elements = interfaceRealization.getRelatedElements();
		EList<Element> elements2 = interfaceRealization.getRelatedElements();
		assertSame(elements, elements2);
	}

	public void testSource() {
		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);
		EList<Element> elements = interfaceRealization.getSources();
		EList<Element> elements2 = interfaceRealization.getSources();
		assertSame(elements, elements2);
	}

	public void testTarget() {
		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);
		EList<Element> elements = interfaceRealization.getTargets();
		EList<Element> elements2 = interfaceRealization.getTargets();
		assertSame(elements, elements2);
	}

	public void testClient() {
		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);

		Activity activity = UML.createActivity();
		assertValid(activity);
		interfaceRealization.getClients().add(activity);
		assertSuperset(interfaceRealization.getSources().contains(activity));

		CommunicationPath communicationPath = UML.createCommunicationPath();
		assertValid(communicationPath);
		interfaceRealization.getClients().add(communicationPath);
		assertSuperset(
			interfaceRealization.getSources().contains(communicationPath));

		ReadSelfAction readSelfAction = UML.createReadSelfAction();
		assertValid(readSelfAction);
		interfaceRealization.getClients().add(readSelfAction);
		assertSuperset(
			interfaceRealization.getSources().contains(readSelfAction));

		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);
		interfaceRealization.getClients().add(activityPartition);
		assertSuperset(
			interfaceRealization.getSources().contains(activityPartition));

		InputPin inputPin = UML.createInputPin();
		assertValid(inputPin);
		interfaceRealization.getClients().add(inputPin);
		assertSuperset(interfaceRealization.getSources().contains(inputPin));

		ReadLinkObjectEndQualifierAction readLinkObjectEndQualifierAction = UML
			.createReadLinkObjectEndQualifierAction();
		assertValid(readLinkObjectEndQualifierAction);
		interfaceRealization.getClients().add(readLinkObjectEndQualifierAction);
		assertSuperset(interfaceRealization.getSources()
			.contains(readLinkObjectEndQualifierAction));

		Component component = UML.createComponent();
		assertValid(component);
		interfaceRealization.getClients().add(component);
		assertSuperset(interfaceRealization.getSources().contains(component));

		Manifestation manifestation = UML.createManifestation();
		assertValid(manifestation);
		interfaceRealization.getClients().add(manifestation);
		assertSuperset(
			interfaceRealization.getSources().contains(manifestation));

		DurationObservation durationObservation = UML
			.createDurationObservation();
		assertValid(durationObservation);
		interfaceRealization.getClients().add(durationObservation);
		assertSuperset(
			interfaceRealization.getSources().contains(durationObservation));

		CallEvent callEvent = UML.createCallEvent();
		assertValid(callEvent);
		interfaceRealization.getClients().add(callEvent);
		assertSuperset(interfaceRealization.getSources().contains(callEvent));

		JoinNode joinNode = UML.createJoinNode();
		assertValid(joinNode);
		interfaceRealization.getClients().add(joinNode);
		assertSuperset(interfaceRealization.getSources().contains(joinNode));

		Interaction interaction = UML.createInteraction();
		assertValid(interaction);
		interfaceRealization.getClients().add(interaction);
		assertSuperset(interfaceRealization.getSources().contains(interaction));

		CreateLinkObjectAction createLinkObjectAction = UML
			.createCreateLinkObjectAction();
		assertValid(createLinkObjectAction);
		interfaceRealization.getClients().add(createLinkObjectAction);
		assertSuperset(
			interfaceRealization.getSources().contains(createLinkObjectAction));

		OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior();
		assertValid(opaqueBehavior);
		interfaceRealization.getClients().add(opaqueBehavior);
		assertSuperset(
			interfaceRealization.getSources().contains(opaqueBehavior));

		LiteralUnlimitedNatural literalUnlimitedNatural = UML
			.createLiteralUnlimitedNatural();
		assertValid(literalUnlimitedNatural);
		interfaceRealization.getClients().add(literalUnlimitedNatural);
		assertSuperset(interfaceRealization.getSources()
			.contains(literalUnlimitedNatural));

		SendSignalAction sendSignalAction = UML.createSendSignalAction();
		assertValid(sendSignalAction);
		interfaceRealization.getClients().add(sendSignalAction);
		assertSuperset(
			interfaceRealization.getSources().contains(sendSignalAction));

		ReadLinkAction readLinkAction = UML.createReadLinkAction();
		assertValid(readLinkAction);
		interfaceRealization.getClients().add(readLinkAction);
		assertSuperset(
			interfaceRealization.getSources().contains(readLinkAction));

		Operation operation = UML.createOperation();
		assertValid(operation);
		interfaceRealization.getClients().add(operation);
		assertSuperset(interfaceRealization.getSources().contains(operation));

		ClearAssociationAction clearAssociationAction = UML
			.createClearAssociationAction();
		assertValid(clearAssociationAction);
		interfaceRealization.getClients().add(clearAssociationAction);
		assertSuperset(
			interfaceRealization.getSources().contains(clearAssociationAction));

		Model model = UML.createModel();
		assertValid(model);
		interfaceRealization.getClients().add(model);
		assertSuperset(interfaceRealization.getSources().contains(model));

		Parameter parameter = UML.createParameter();
		assertValid(parameter);
		interfaceRealization.getClients().add(parameter);
		assertSuperset(interfaceRealization.getSources().contains(parameter));

		InstanceValue instanceValue = UML.createInstanceValue();
		assertValid(instanceValue);
		interfaceRealization.getClients().add(instanceValue);
		assertSuperset(
			interfaceRealization.getSources().contains(instanceValue));

		Trigger trigger = UML.createTrigger();
		assertValid(trigger);
		interfaceRealization.getClients().add(trigger);
		assertSuperset(interfaceRealization.getSources().contains(trigger));

		InteractionConstraint interactionConstraint = UML
			.createInteractionConstraint();
		assertValid(interactionConstraint);
		interfaceRealization.getClients().add(interactionConstraint);
		assertSuperset(
			interfaceRealization.getSources().contains(interactionConstraint));

		AssociationClass associationClass = UML.createAssociationClass();
		assertValid(associationClass);
		interfaceRealization.getClients().add(associationClass);
		assertSuperset(
			interfaceRealization.getSources().contains(associationClass));

		InteractionUse interactionUse = UML.createInteractionUse();
		assertValid(interactionUse);
		interfaceRealization.getClients().add(interactionUse);
		assertSuperset(
			interfaceRealization.getSources().contains(interactionUse));

		ClearStructuralFeatureAction clearStructuralFeatureAction = UML
			.createClearStructuralFeatureAction();
		assertValid(clearStructuralFeatureAction);
		interfaceRealization.getClients().add(clearStructuralFeatureAction);
		assertSuperset(interfaceRealization.getSources()
			.contains(clearStructuralFeatureAction));

		Interval interval = UML.createInterval();
		assertValid(interval);
		interfaceRealization.getClients().add(interval);
		assertSuperset(interfaceRealization.getSources().contains(interval));

		StructuredActivityNode structuredActivityNode = UML
			.createStructuredActivityNode();
		assertValid(structuredActivityNode);
		interfaceRealization.getClients().add(structuredActivityNode);
		assertSuperset(
			interfaceRealization.getSources().contains(structuredActivityNode));

		LiteralString literalString = UML.createLiteralString();
		assertValid(literalString);
		interfaceRealization.getClients().add(literalString);
		assertSuperset(
			interfaceRealization.getSources().contains(literalString));

		ValuePin valuePin = UML.createValuePin();
		assertValid(valuePin);
		interfaceRealization.getClients().add(valuePin);
		assertSuperset(interfaceRealization.getSources().contains(valuePin));

		InterfaceRealization interfaceRealization2 = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization2);
		interfaceRealization.getClients().add(interfaceRealization2);
		assertSuperset(
			interfaceRealization.getSources().contains(interfaceRealization2));

		ForkNode forkNode = UML.createForkNode();
		assertValid(forkNode);
		interfaceRealization.getClients().add(forkNode);
		assertSuperset(interfaceRealization.getSources().contains(forkNode));

		DecisionNode decisionNode = UML.createDecisionNode();
		assertValid(decisionNode);
		interfaceRealization.getClients().add(decisionNode);
		assertSuperset(
			interfaceRealization.getSources().contains(decisionNode));

		Actor actor = UML.createActor();
		assertValid(actor);
		interfaceRealization.getClients().add(actor);
		assertSuperset(interfaceRealization.getSources().contains(actor));

		TimeConstraint timeConstraint = UML.createTimeConstraint();
		assertValid(timeConstraint);
		interfaceRealization.getClients().add(timeConstraint);
		assertSuperset(
			interfaceRealization.getSources().contains(timeConstraint));

		Reception reception = UML.createReception();
		assertValid(reception);
		interfaceRealization.getClients().add(reception);
		assertSuperset(interfaceRealization.getSources().contains(reception));

		Pseudostate pseudostate = UML.createPseudostate();
		assertValid(pseudostate);
		interfaceRealization.getClients().add(pseudostate);
		assertSuperset(interfaceRealization.getSources().contains(pseudostate));

		DurationInterval durationInterval = UML.createDurationInterval();
		assertValid(durationInterval);
		interfaceRealization.getClients().add(durationInterval);
		assertSuperset(
			interfaceRealization.getSources().contains(durationInterval));

		Deployment deployment = UML.createDeployment();
		assertValid(deployment);
		interfaceRealization.getClients().add(deployment);
		assertSuperset(interfaceRealization.getSources().contains(deployment));

		ExtensionEnd extensionEnd = UML.createExtensionEnd();
		assertValid(extensionEnd);
		interfaceRealization.getClients().add(extensionEnd);
		assertSuperset(
			interfaceRealization.getSources().contains(extensionEnd));

		ConsiderIgnoreFragment considerIgnoreFragment = UML
			.createConsiderIgnoreFragment();
		assertValid(considerIgnoreFragment);
		interfaceRealization.getClients().add(considerIgnoreFragment);
		assertSuperset(
			interfaceRealization.getSources().contains(considerIgnoreFragment));

		ConditionalNode conditionalNode = UML.createConditionalNode();
		assertValid(conditionalNode);
		interfaceRealization.getClients().add(conditionalNode);
		assertSuperset(
			interfaceRealization.getSources().contains(conditionalNode));

		ReadExtentAction readExtentAction = UML.createReadExtentAction();
		assertValid(readExtentAction);
		interfaceRealization.getClients().add(readExtentAction);
		assertSuperset(
			interfaceRealization.getSources().contains(readExtentAction));

		ActionInputPin actionInputPin = UML.createActionInputPin();
		assertValid(actionInputPin);
		interfaceRealization.getClients().add(actionInputPin);
		assertSuperset(
			interfaceRealization.getSources().contains(actionInputPin));

		Artifact artifact = UML.createArtifact();
		assertValid(artifact);
		interfaceRealization.getClients().add(artifact);
		assertSuperset(interfaceRealization.getSources().contains(artifact));

		InformationFlow informationFlow = UML.createInformationFlow();
		assertValid(informationFlow);
		interfaceRealization.getClients().add(informationFlow);
		assertSuperset(
			interfaceRealization.getSources().contains(informationFlow));

		ClearVariableAction clearVariableAction = UML
			.createClearVariableAction();
		assertValid(clearVariableAction);
		interfaceRealization.getClients().add(clearVariableAction);
		assertSuperset(
			interfaceRealization.getSources().contains(clearVariableAction));

		CreateLinkAction createLinkAction = UML.createCreateLinkAction();
		assertValid(createLinkAction);
		interfaceRealization.getClients().add(createLinkAction);
		assertSuperset(
			interfaceRealization.getSources().contains(createLinkAction));

		SignalEvent signalEvent = UML.createSignalEvent();
		assertValid(signalEvent);
		interfaceRealization.getClients().add(signalEvent);
		assertSuperset(interfaceRealization.getSources().contains(signalEvent));

		ConnectionPointReference connectionPointReference = UML
			.createConnectionPointReference();
		assertValid(connectionPointReference);
		interfaceRealization.getClients().add(connectionPointReference);
		assertSuperset(interfaceRealization.getSources()
			.contains(connectionPointReference));

		ReclassifyObjectAction reclassifyObjectAction = UML
			.createReclassifyObjectAction();
		assertValid(reclassifyObjectAction);
		interfaceRealization.getClients().add(reclassifyObjectAction);
		assertSuperset(
			interfaceRealization.getSources().contains(reclassifyObjectAction));

		Usage usage = UML.createUsage();
		assertValid(usage);
		interfaceRealization.getClients().add(usage);
		assertSuperset(interfaceRealization.getSources().contains(usage));

		DataStoreNode dataStoreNode = UML.createDataStoreNode();
		assertValid(dataStoreNode);
		interfaceRealization.getClients().add(dataStoreNode);
		assertSuperset(
			interfaceRealization.getSources().contains(dataStoreNode));

		ExecutionEnvironment executionEnvironment = UML
			.createExecutionEnvironment();
		assertValid(executionEnvironment);
		interfaceRealization.getClients().add(executionEnvironment);
		assertSuperset(
			interfaceRealization.getSources().contains(executionEnvironment));

		SendObjectAction sendObjectAction = UML.createSendObjectAction();
		assertValid(sendObjectAction);
		interfaceRealization.getClients().add(sendObjectAction);
		assertSuperset(
			interfaceRealization.getSources().contains(sendObjectAction));

		ControlFlow controlFlow = UML.createControlFlow();
		assertValid(controlFlow);
		interfaceRealization.getClients().add(controlFlow);
		assertSuperset(interfaceRealization.getSources().contains(controlFlow));

		DeploymentSpecification deploymentSpecification = UML
			.createDeploymentSpecification();
		assertValid(deploymentSpecification);
		interfaceRealization.getClients().add(deploymentSpecification);
		assertSuperset(interfaceRealization.getSources()
			.contains(deploymentSpecification));

		PartDecomposition partDecomposition = UML.createPartDecomposition();
		assertValid(partDecomposition);
		interfaceRealization.getClients().add(partDecomposition);
		assertSuperset(
			interfaceRealization.getSources().contains(partDecomposition));

		DestroyLinkAction destroyLinkAction = UML.createDestroyLinkAction();
		assertValid(destroyLinkAction);
		interfaceRealization.getClients().add(destroyLinkAction);
		assertSuperset(
			interfaceRealization.getSources().contains(destroyLinkAction));

		Realization realization = UML.createRealization();
		assertValid(realization);
		interfaceRealization.getClients().add(realization);
		assertSuperset(interfaceRealization.getSources().contains(realization));

		ExpansionNode expansionNode = UML.createExpansionNode();
		assertValid(expansionNode);
		interfaceRealization.getClients().add(expansionNode);
		assertSuperset(
			interfaceRealization.getSources().contains(expansionNode));

		TestIdentityAction testIdentityAction = UML.createTestIdentityAction();
		assertValid(testIdentityAction);
		interfaceRealization.getClients().add(testIdentityAction);
		assertSuperset(
			interfaceRealization.getSources().contains(testIdentityAction));

		Association association = UML.createAssociation();
		assertValid(association);
		interfaceRealization.getClients().add(association);
		assertSuperset(interfaceRealization.getSources().contains(association));

		TimeInterval timeInterval = UML.createTimeInterval();
		assertValid(timeInterval);
		interfaceRealization.getClients().add(timeInterval);
		assertSuperset(
			interfaceRealization.getSources().contains(timeInterval));

		DataType dataType = UML.createDataType();
		assertValid(dataType);
		interfaceRealization.getClients().add(dataType);
		assertSuperset(interfaceRealization.getSources().contains(dataType));

		OutputPin outputPin = UML.createOutputPin();
		assertValid(outputPin);
		interfaceRealization.getClients().add(outputPin);
		assertSuperset(interfaceRealization.getSources().contains(outputPin));

		Substitution substitution = UML.createSubstitution();
		assertValid(substitution);
		interfaceRealization.getClients().add(substitution);
		assertSuperset(
			interfaceRealization.getSources().contains(substitution));

		Include include = UML.createInclude();
		assertValid(include);
		interfaceRealization.getClients().add(include);
		assertSuperset(interfaceRealization.getSources().contains(include));

		Extend extend = UML.createExtend();
		assertValid(extend);
		interfaceRealization.getClients().add(extend);
		assertSuperset(interfaceRealization.getSources().contains(extend));

		BroadcastSignalAction broadcastSignalAction = UML
			.createBroadcastSignalAction();
		assertValid(broadcastSignalAction);
		interfaceRealization.getClients().add(broadcastSignalAction);
		assertSuperset(
			interfaceRealization.getSources().contains(broadcastSignalAction));

		LiteralBoolean literalBoolean = UML.createLiteralBoolean();
		assertValid(literalBoolean);
		interfaceRealization.getClients().add(literalBoolean);
		assertSuperset(
			interfaceRealization.getSources().contains(literalBoolean));

		FinalState finalState = UML.createFinalState();
		assertValid(finalState);
		interfaceRealization.getClients().add(finalState);
		assertSuperset(interfaceRealization.getSources().contains(finalState));

		RaiseExceptionAction raiseExceptionAction = UML
			.createRaiseExceptionAction();
		assertValid(raiseExceptionAction);
		interfaceRealization.getClients().add(raiseExceptionAction);
		assertSuperset(
			interfaceRealization.getSources().contains(raiseExceptionAction));

		DurationConstraint durationConstraint = UML.createDurationConstraint();
		assertValid(durationConstraint);
		interfaceRealization.getClients().add(durationConstraint);
		assertSuperset(
			interfaceRealization.getSources().contains(durationConstraint));

		ActivityFinalNode activityFinalNode = UML.createActivityFinalNode();
		assertValid(activityFinalNode);
		interfaceRealization.getClients().add(activityFinalNode);
		assertSuperset(
			interfaceRealization.getSources().contains(activityFinalNode));

		LiteralNull literalNull = UML.createLiteralNull();
		assertValid(literalNull);
		interfaceRealization.getClients().add(literalNull);
		assertSuperset(interfaceRealization.getSources().contains(literalNull));

		CallOperationAction callOperationAction = UML
			.createCallOperationAction();
		assertValid(callOperationAction);
		interfaceRealization.getClients().add(callOperationAction);
		assertSuperset(
			interfaceRealization.getSources().contains(callOperationAction));

		ProtocolStateMachine protocolStateMachine = UML
			.createProtocolStateMachine();
		assertValid(protocolStateMachine);
		interfaceRealization.getClients().add(protocolStateMachine);
		assertSuperset(
			interfaceRealization.getSources().contains(protocolStateMachine));

		LoopNode loopNode = UML.createLoopNode();
		assertValid(loopNode);
		interfaceRealization.getClients().add(loopNode);
		assertSuperset(interfaceRealization.getSources().contains(loopNode));

		ParameterSet parameterSet = UML.createParameterSet();
		assertValid(parameterSet);
		interfaceRealization.getClients().add(parameterSet);
		assertSuperset(
			interfaceRealization.getSources().contains(parameterSet));

		ValueSpecificationAction valueSpecificationAction = UML
			.createValueSpecificationAction();
		assertValid(valueSpecificationAction);
		interfaceRealization.getClients().add(valueSpecificationAction);
		assertSuperset(interfaceRealization.getSources()
			.contains(valueSpecificationAction));

		Node node = UML.createNode();
		assertValid(node);
		interfaceRealization.getClients().add(node);
		assertSuperset(interfaceRealization.getSources().contains(node));

		SequenceNode sequenceNode = UML.createSequenceNode();
		assertValid(sequenceNode);
		interfaceRealization.getClients().add(sequenceNode);
		assertSuperset(
			interfaceRealization.getSources().contains(sequenceNode));

		Constraint constraint = UML.createConstraint();
		assertValid(constraint);
		interfaceRealization.getClients().add(constraint);
		assertSuperset(interfaceRealization.getSources().contains(constraint));

		DestroyObjectAction destroyObjectAction = UML
			.createDestroyObjectAction();
		assertValid(destroyObjectAction);
		interfaceRealization.getClients().add(destroyObjectAction);
		assertSuperset(
			interfaceRealization.getSources().contains(destroyObjectAction));

		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		interfaceRealization.getClients().add(stateMachine);
		assertSuperset(
			interfaceRealization.getSources().contains(stateMachine));

		EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral();
		assertValid(enumerationLiteral);
		interfaceRealization.getClients().add(enumerationLiteral);
		assertSuperset(
			interfaceRealization.getSources().contains(enumerationLiteral));

		ActionExecutionSpecification actionExecutionSpecification = UML
			.createActionExecutionSpecification();
		assertValid(actionExecutionSpecification);
		interfaceRealization.getClients().add(actionExecutionSpecification);
		assertSuperset(interfaceRealization.getSources()
			.contains(actionExecutionSpecification));

		FunctionBehavior functionBehavior = UML.createFunctionBehavior();
		assertValid(functionBehavior);
		interfaceRealization.getClients().add(functionBehavior);
		assertSuperset(
			interfaceRealization.getSources().contains(functionBehavior));

		Interface interface_ = UML.createInterface();
		assertValid(interface_);
		interfaceRealization.getClients().add(interface_);
		assertSuperset(interfaceRealization.getSources().contains(interface_));

		InstanceSpecification instanceSpecification = UML
			.createInstanceSpecification();
		assertValid(instanceSpecification);
		interfaceRealization.getClients().add(instanceSpecification);
		assertSuperset(
			interfaceRealization.getSources().contains(instanceSpecification));

		StartClassifierBehaviorAction startClassifierBehaviorAction = UML
			.createStartClassifierBehaviorAction();
		assertValid(startClassifierBehaviorAction);
		interfaceRealization.getClients().add(startClassifierBehaviorAction);
		assertSuperset(interfaceRealization.getSources()
			.contains(startClassifierBehaviorAction));

		Port port = UML.createPort();
		assertValid(port);
		interfaceRealization.getClients().add(port);
		assertSuperset(interfaceRealization.getSources().contains(port));

		RemoveVariableValueAction removeVariableValueAction = UML
			.createRemoveVariableValueAction();
		assertValid(removeVariableValueAction);
		interfaceRealization.getClients().add(removeVariableValueAction);
		assertSuperset(interfaceRealization.getSources()
			.contains(removeVariableValueAction));

		InformationItem informationItem = UML.createInformationItem();
		assertValid(informationItem);
		interfaceRealization.getClients().add(informationItem);
		assertSuperset(
			interfaceRealization.getSources().contains(informationItem));

		LiteralReal literalReal = UML.createLiteralReal();
		assertValid(literalReal);
		interfaceRealization.getClients().add(literalReal);
		assertSuperset(interfaceRealization.getSources().contains(literalReal));

		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);
		interfaceRealization.getClients().add(redefinableTemplateSignature);
		assertSuperset(interfaceRealization.getSources()
			.contains(redefinableTemplateSignature));

		ExecutionOccurrenceSpecification executionOccurrenceSpecification = UML
			.createExecutionOccurrenceSpecification();
		assertValid(executionOccurrenceSpecification);
		interfaceRealization.getClients().add(executionOccurrenceSpecification);
		assertSuperset(interfaceRealization.getSources()
			.contains(executionOccurrenceSpecification));

		Duration duration = UML.createDuration();
		assertValid(duration);
		interfaceRealization.getClients().add(duration);
		assertSuperset(interfaceRealization.getSources().contains(duration));

		org.eclipse.uml2.uml.Package package_ = UML.createPackage();
		assertValid(package_);
		interfaceRealization.getClients().add(package_);
		assertSuperset(interfaceRealization.getSources().contains(package_));

		Variable variable = UML.createVariable();
		assertValid(variable);
		interfaceRealization.getClients().add(variable);
		assertSuperset(interfaceRealization.getSources().contains(variable));

		DestructionOccurrenceSpecification destructionOccurrenceSpecification = UML
			.createDestructionOccurrenceSpecification();
		assertValid(destructionOccurrenceSpecification);
		interfaceRealization.getClients()
			.add(destructionOccurrenceSpecification);
		assertSuperset(interfaceRealization.getSources()
			.contains(destructionOccurrenceSpecification));

		Lifeline lifeline = UML.createLifeline();
		assertValid(lifeline);
		interfaceRealization.getClients().add(lifeline);
		assertSuperset(interfaceRealization.getSources().contains(lifeline));

		TimeObservation timeObservation = UML.createTimeObservation();
		assertValid(timeObservation);
		interfaceRealization.getClients().add(timeObservation);
		assertSuperset(
			interfaceRealization.getSources().contains(timeObservation));

		ReplyAction replyAction = UML.createReplyAction();
		assertValid(replyAction);
		interfaceRealization.getClients().add(replyAction);
		assertSuperset(interfaceRealization.getSources().contains(replyAction));

		Gate gate = UML.createGate();
		assertValid(gate);
		interfaceRealization.getClients().add(gate);
		assertSuperset(interfaceRealization.getSources().contains(gate));

		Property property = UML.createProperty();
		assertValid(property);
		interfaceRealization.getClients().add(property);
		assertSuperset(interfaceRealization.getSources().contains(property));

		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);
		interfaceRealization.getClients().add(timeExpression);
		assertSuperset(
			interfaceRealization.getSources().contains(timeExpression));

		Device device = UML.createDevice();
		assertValid(device);
		interfaceRealization.getClients().add(device);
		assertSuperset(interfaceRealization.getSources().contains(device));

		FlowFinalNode flowFinalNode = UML.createFlowFinalNode();
		assertValid(flowFinalNode);
		interfaceRealization.getClients().add(flowFinalNode);
		assertSuperset(
			interfaceRealization.getSources().contains(flowFinalNode));

		ExpansionRegion expansionRegion = UML.createExpansionRegion();
		assertValid(expansionRegion);
		interfaceRealization.getClients().add(expansionRegion);
		assertSuperset(
			interfaceRealization.getSources().contains(expansionRegion));

		Abstraction abstraction = UML.createAbstraction();
		assertValid(abstraction);
		interfaceRealization.getClients().add(abstraction);
		assertSuperset(interfaceRealization.getSources().contains(abstraction));

		StartObjectBehaviorAction startObjectBehaviorAction = UML
			.createStartObjectBehaviorAction();
		assertValid(startObjectBehaviorAction);
		interfaceRealization.getClients().add(startObjectBehaviorAction);
		assertSuperset(interfaceRealization.getSources()
			.contains(startObjectBehaviorAction));

		Enumeration enumeration = UML.createEnumeration();
		assertValid(enumeration);
		interfaceRealization.getClients().add(enumeration);
		assertSuperset(interfaceRealization.getSources().contains(enumeration));

		PrimitiveType primitiveType = UML.createPrimitiveType();
		assertValid(primitiveType);
		interfaceRealization.getClients().add(primitiveType);
		assertSuperset(
			interfaceRealization.getSources().contains(primitiveType));

		Profile profile = UML.createProfile();
		assertValid(profile);
		interfaceRealization.getClients().add(profile);
		assertSuperset(interfaceRealization.getSources().contains(profile));

		Message message = UML.createMessage();
		assertValid(message);
		interfaceRealization.getClients().add(message);
		assertSuperset(interfaceRealization.getSources().contains(message));

		GeneralizationSet generalizationSet = UML.createGeneralizationSet();
		assertValid(generalizationSet);
		interfaceRealization.getClients().add(generalizationSet);
		assertSuperset(
			interfaceRealization.getSources().contains(generalizationSet));

		Continuation continuation = UML.createContinuation();
		assertValid(continuation);
		interfaceRealization.getClients().add(continuation);
		assertSuperset(
			interfaceRealization.getSources().contains(continuation));

		Signal signal = UML.createSignal();
		assertValid(signal);
		interfaceRealization.getClients().add(signal);
		assertSuperset(interfaceRealization.getSources().contains(signal));

		CallBehaviorAction callBehaviorAction = UML.createCallBehaviorAction();
		assertValid(callBehaviorAction);
		interfaceRealization.getClients().add(callBehaviorAction);
		assertSuperset(
			interfaceRealization.getSources().contains(callBehaviorAction));

		ObjectFlow objectFlow = UML.createObjectFlow();
		assertValid(objectFlow);
		interfaceRealization.getClients().add(objectFlow);
		assertSuperset(interfaceRealization.getSources().contains(objectFlow));

		StateInvariant stateInvariant = UML.createStateInvariant();
		assertValid(stateInvariant);
		interfaceRealization.getClients().add(stateInvariant);
		assertSuperset(
			interfaceRealization.getSources().contains(stateInvariant));

		ReadIsClassifiedObjectAction readIsClassifiedObjectAction = UML
			.createReadIsClassifiedObjectAction();
		assertValid(readIsClassifiedObjectAction);
		interfaceRealization.getClients().add(readIsClassifiedObjectAction);
		assertSuperset(interfaceRealization.getSources()
			.contains(readIsClassifiedObjectAction));

		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);
		interfaceRealization.getClients().add(activityParameterNode);
		assertSuperset(
			interfaceRealization.getSources().contains(activityParameterNode));

		AddStructuralFeatureValueAction addStructuralFeatureValueAction = UML
			.createAddStructuralFeatureValueAction();
		assertValid(addStructuralFeatureValueAction);
		interfaceRealization.getClients().add(addStructuralFeatureValueAction);
		assertSuperset(interfaceRealization.getSources()
			.contains(addStructuralFeatureValueAction));

		ReadVariableAction readVariableAction = UML.createReadVariableAction();
		assertValid(readVariableAction);
		interfaceRealization.getClients().add(readVariableAction);
		assertSuperset(
			interfaceRealization.getSources().contains(readVariableAction));

		InterruptibleActivityRegion interruptibleActivityRegion = UML
			.createInterruptibleActivityRegion();
		assertValid(interruptibleActivityRegion);
		interfaceRealization.getClients().add(interruptibleActivityRegion);
		assertSuperset(interfaceRealization.getSources()
			.contains(interruptibleActivityRegion));

		RemoveStructuralFeatureValueAction removeStructuralFeatureValueAction = UML
			.createRemoveStructuralFeatureValueAction();
		assertValid(removeStructuralFeatureValueAction);
		interfaceRealization.getClients()
			.add(removeStructuralFeatureValueAction);
		assertSuperset(interfaceRealization.getSources()
			.contains(removeStructuralFeatureValueAction));

		OpaqueExpression opaqueExpression = UML.createOpaqueExpression();
		assertValid(opaqueExpression);
		interfaceRealization.getClients().add(opaqueExpression);
		assertSuperset(
			interfaceRealization.getSources().contains(opaqueExpression));

		TimeEvent timeEvent = UML.createTimeEvent();
		assertValid(timeEvent);
		interfaceRealization.getClients().add(timeEvent);
		assertSuperset(interfaceRealization.getSources().contains(timeEvent));

		GeneralOrdering generalOrdering = UML.createGeneralOrdering();
		assertValid(generalOrdering);
		interfaceRealization.getClients().add(generalOrdering);
		assertSuperset(
			interfaceRealization.getSources().contains(generalOrdering));

		Region region = UML.createRegion();
		assertValid(region);
		interfaceRealization.getClients().add(region);
		assertSuperset(interfaceRealization.getSources().contains(region));

		Transition transition = UML.createTransition();
		assertValid(transition);
		interfaceRealization.getClients().add(transition);
		assertSuperset(interfaceRealization.getSources().contains(transition));

		AnyReceiveEvent anyReceiveEvent = UML.createAnyReceiveEvent();
		assertValid(anyReceiveEvent);
		interfaceRealization.getClients().add(anyReceiveEvent);
		assertSuperset(
			interfaceRealization.getSources().contains(anyReceiveEvent));

		MessageOccurrenceSpecification messageOccurrenceSpecification = UML
			.createMessageOccurrenceSpecification();
		assertValid(messageOccurrenceSpecification);
		interfaceRealization.getClients().add(messageOccurrenceSpecification);
		assertSuperset(interfaceRealization.getSources()
			.contains(messageOccurrenceSpecification));

		LiteralInteger literalInteger = UML.createLiteralInteger();
		assertValid(literalInteger);
		interfaceRealization.getClients().add(literalInteger);
		assertSuperset(
			interfaceRealization.getSources().contains(literalInteger));

		ReduceAction reduceAction = UML.createReduceAction();
		assertValid(reduceAction);
		interfaceRealization.getClients().add(reduceAction);
		assertSuperset(
			interfaceRealization.getSources().contains(reduceAction));

		AcceptEventAction acceptEventAction = UML.createAcceptEventAction();
		assertValid(acceptEventAction);
		interfaceRealization.getClients().add(acceptEventAction);
		assertSuperset(
			interfaceRealization.getSources().contains(acceptEventAction));

		InitialNode initialNode = UML.createInitialNode();
		assertValid(initialNode);
		interfaceRealization.getClients().add(initialNode);
		assertSuperset(interfaceRealization.getSources().contains(initialNode));

		CentralBufferNode centralBufferNode = UML.createCentralBufferNode();
		assertValid(centralBufferNode);
		interfaceRealization.getClients().add(centralBufferNode);
		assertSuperset(
			interfaceRealization.getSources().contains(centralBufferNode));

		CombinedFragment combinedFragment = UML.createCombinedFragment();
		assertValid(combinedFragment);
		interfaceRealization.getClients().add(combinedFragment);
		assertSuperset(
			interfaceRealization.getSources().contains(combinedFragment));

		IntervalConstraint intervalConstraint = UML.createIntervalConstraint();
		assertValid(intervalConstraint);
		interfaceRealization.getClients().add(intervalConstraint);
		assertSuperset(
			interfaceRealization.getSources().contains(intervalConstraint));

		Extension extension = UML.createExtension();
		assertValid(extension);
		interfaceRealization.getClients().add(extension);
		assertSuperset(interfaceRealization.getSources().contains(extension));

		OccurrenceSpecification occurrenceSpecification = UML
			.createOccurrenceSpecification();
		assertValid(occurrenceSpecification);
		interfaceRealization.getClients().add(occurrenceSpecification);
		assertSuperset(interfaceRealization.getSources()
			.contains(occurrenceSpecification));

		ExtensionPoint extensionPoint = UML.createExtensionPoint();
		assertValid(extensionPoint);
		interfaceRealization.getClients().add(extensionPoint);
		assertSuperset(
			interfaceRealization.getSources().contains(extensionPoint));

		Dependency dependency = UML.createDependency();
		assertValid(dependency);
		interfaceRealization.getClients().add(dependency);
		assertSuperset(interfaceRealization.getSources().contains(dependency));

		Connector connector = UML.createConnector();
		assertValid(connector);
		interfaceRealization.getClients().add(connector);
		assertSuperset(interfaceRealization.getSources().contains(connector));

		Expression expression = UML.createExpression();
		assertValid(expression);
		interfaceRealization.getClients().add(expression);
		assertSuperset(interfaceRealization.getSources().contains(expression));

		ComponentRealization componentRealization = UML
			.createComponentRealization();
		assertValid(componentRealization);
		interfaceRealization.getClients().add(componentRealization);
		assertSuperset(
			interfaceRealization.getSources().contains(componentRealization));

		org.eclipse.uml2.uml.Class class_ = UML.createClass();
		assertValid(class_);
		interfaceRealization.getClients().add(class_);
		assertSuperset(interfaceRealization.getSources().contains(class_));

		State state = UML.createState();
		assertValid(state);
		interfaceRealization.getClients().add(state);
		assertSuperset(interfaceRealization.getSources().contains(state));

		ProtocolTransition protocolTransition = UML.createProtocolTransition();
		assertValid(protocolTransition);
		interfaceRealization.getClients().add(protocolTransition);
		assertSuperset(
			interfaceRealization.getSources().contains(protocolTransition));

		BehaviorExecutionSpecification behaviorExecutionSpecification = UML
			.createBehaviorExecutionSpecification();
		assertValid(behaviorExecutionSpecification);
		interfaceRealization.getClients().add(behaviorExecutionSpecification);
		assertSuperset(interfaceRealization.getSources()
			.contains(behaviorExecutionSpecification));

		CollaborationUse collaborationUse = UML.createCollaborationUse();
		assertValid(collaborationUse);
		interfaceRealization.getClients().add(collaborationUse);
		assertSuperset(
			interfaceRealization.getSources().contains(collaborationUse));

		InteractionOperand interactionOperand = UML.createInteractionOperand();
		assertValid(interactionOperand);
		interfaceRealization.getClients().add(interactionOperand);
		assertSuperset(
			interfaceRealization.getSources().contains(interactionOperand));

		AcceptCallAction acceptCallAction = UML.createAcceptCallAction();
		assertValid(acceptCallAction);
		interfaceRealization.getClients().add(acceptCallAction);
		assertSuperset(
			interfaceRealization.getSources().contains(acceptCallAction));

		AddVariableValueAction addVariableValueAction = UML
			.createAddVariableValueAction();
		assertValid(addVariableValueAction);
		interfaceRealization.getClients().add(addVariableValueAction);
		assertSuperset(
			interfaceRealization.getSources().contains(addVariableValueAction));

		ReadLinkObjectEndAction readLinkObjectEndAction = UML
			.createReadLinkObjectEndAction();
		assertValid(readLinkObjectEndAction);
		interfaceRealization.getClients().add(readLinkObjectEndAction);
		assertSuperset(interfaceRealization.getSources()
			.contains(readLinkObjectEndAction));

		UseCase useCase = UML.createUseCase();
		assertValid(useCase);
		interfaceRealization.getClients().add(useCase);
		assertSuperset(interfaceRealization.getSources().contains(useCase));

		UnmarshallAction unmarshallAction = UML.createUnmarshallAction();
		assertValid(unmarshallAction);
		interfaceRealization.getClients().add(unmarshallAction);
		assertSuperset(
			interfaceRealization.getSources().contains(unmarshallAction));

		OpaqueAction opaqueAction = UML.createOpaqueAction();
		assertValid(opaqueAction);
		interfaceRealization.getClients().add(opaqueAction);
		assertSuperset(
			interfaceRealization.getSources().contains(opaqueAction));

		StringExpression stringExpression = UML.createStringExpression();
		assertValid(stringExpression);
		interfaceRealization.getClients().add(stringExpression);
		assertSuperset(
			interfaceRealization.getSources().contains(stringExpression));

		MergeNode mergeNode = UML.createMergeNode();
		assertValid(mergeNode);
		interfaceRealization.getClients().add(mergeNode);
		assertSuperset(interfaceRealization.getSources().contains(mergeNode));

		ChangeEvent changeEvent = UML.createChangeEvent();
		assertValid(changeEvent);
		interfaceRealization.getClients().add(changeEvent);
		assertSuperset(interfaceRealization.getSources().contains(changeEvent));

		CreateObjectAction createObjectAction = UML.createCreateObjectAction();
		assertValid(createObjectAction);
		interfaceRealization.getClients().add(createObjectAction);
		assertSuperset(
			interfaceRealization.getSources().contains(createObjectAction));

		Stereotype stereotype = UML.createStereotype();
		assertValid(stereotype);
		interfaceRealization.getClients().add(stereotype);
		assertSuperset(interfaceRealization.getSources().contains(stereotype));

		ReadStructuralFeatureAction readStructuralFeatureAction = UML
			.createReadStructuralFeatureAction();
		assertValid(readStructuralFeatureAction);
		interfaceRealization.getClients().add(readStructuralFeatureAction);
		assertSuperset(interfaceRealization.getSources()
			.contains(readStructuralFeatureAction));

		Collaboration collaboration = UML.createCollaboration();
		assertValid(collaboration);
		interfaceRealization.getClients().add(collaboration);
		assertSuperset(
			interfaceRealization.getSources().contains(collaboration));
	}

	public void testSupplier() {
		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);

		Activity activity = UML.createActivity();
		assertValid(activity);
		interfaceRealization.getSuppliers().add(activity);
		assertSuperset(interfaceRealization.getTargets().contains(activity));

		CommunicationPath communicationPath = UML.createCommunicationPath();
		assertValid(communicationPath);
		interfaceRealization.getSuppliers().add(communicationPath);
		assertSuperset(
			interfaceRealization.getTargets().contains(communicationPath));

		ReadSelfAction readSelfAction = UML.createReadSelfAction();
		assertValid(readSelfAction);
		interfaceRealization.getSuppliers().add(readSelfAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(readSelfAction));

		ActivityPartition activityPartition = UML.createActivityPartition();
		assertValid(activityPartition);
		interfaceRealization.getSuppliers().add(activityPartition);
		assertSuperset(
			interfaceRealization.getTargets().contains(activityPartition));

		InputPin inputPin = UML.createInputPin();
		assertValid(inputPin);
		interfaceRealization.getSuppliers().add(inputPin);
		assertSuperset(interfaceRealization.getTargets().contains(inputPin));

		ReadLinkObjectEndQualifierAction readLinkObjectEndQualifierAction = UML
			.createReadLinkObjectEndQualifierAction();
		assertValid(readLinkObjectEndQualifierAction);
		interfaceRealization.getSuppliers()
			.add(readLinkObjectEndQualifierAction);
		assertSuperset(interfaceRealization.getTargets()
			.contains(readLinkObjectEndQualifierAction));

		Component component = UML.createComponent();
		assertValid(component);
		interfaceRealization.getSuppliers().add(component);
		assertSuperset(interfaceRealization.getTargets().contains(component));

		Manifestation manifestation = UML.createManifestation();
		assertValid(manifestation);
		interfaceRealization.getSuppliers().add(manifestation);
		assertSuperset(
			interfaceRealization.getTargets().contains(manifestation));

		DurationObservation durationObservation = UML
			.createDurationObservation();
		assertValid(durationObservation);
		interfaceRealization.getSuppliers().add(durationObservation);
		assertSuperset(
			interfaceRealization.getTargets().contains(durationObservation));

		CallEvent callEvent = UML.createCallEvent();
		assertValid(callEvent);
		interfaceRealization.getSuppliers().add(callEvent);
		assertSuperset(interfaceRealization.getTargets().contains(callEvent));

		JoinNode joinNode = UML.createJoinNode();
		assertValid(joinNode);
		interfaceRealization.getSuppliers().add(joinNode);
		assertSuperset(interfaceRealization.getTargets().contains(joinNode));

		Interaction interaction = UML.createInteraction();
		assertValid(interaction);
		interfaceRealization.getSuppliers().add(interaction);
		assertSuperset(interfaceRealization.getTargets().contains(interaction));

		CreateLinkObjectAction createLinkObjectAction = UML
			.createCreateLinkObjectAction();
		assertValid(createLinkObjectAction);
		interfaceRealization.getSuppliers().add(createLinkObjectAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(createLinkObjectAction));

		OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior();
		assertValid(opaqueBehavior);
		interfaceRealization.getSuppliers().add(opaqueBehavior);
		assertSuperset(
			interfaceRealization.getTargets().contains(opaqueBehavior));

		LiteralUnlimitedNatural literalUnlimitedNatural = UML
			.createLiteralUnlimitedNatural();
		assertValid(literalUnlimitedNatural);
		interfaceRealization.getSuppliers().add(literalUnlimitedNatural);
		assertSuperset(interfaceRealization.getTargets()
			.contains(literalUnlimitedNatural));

		SendSignalAction sendSignalAction = UML.createSendSignalAction();
		assertValid(sendSignalAction);
		interfaceRealization.getSuppliers().add(sendSignalAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(sendSignalAction));

		ReadLinkAction readLinkAction = UML.createReadLinkAction();
		assertValid(readLinkAction);
		interfaceRealization.getSuppliers().add(readLinkAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(readLinkAction));

		Operation operation = UML.createOperation();
		assertValid(operation);
		interfaceRealization.getSuppliers().add(operation);
		assertSuperset(interfaceRealization.getTargets().contains(operation));

		ClearAssociationAction clearAssociationAction = UML
			.createClearAssociationAction();
		assertValid(clearAssociationAction);
		interfaceRealization.getSuppliers().add(clearAssociationAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(clearAssociationAction));

		Model model = UML.createModel();
		assertValid(model);
		interfaceRealization.getSuppliers().add(model);
		assertSuperset(interfaceRealization.getTargets().contains(model));

		Parameter parameter = UML.createParameter();
		assertValid(parameter);
		interfaceRealization.getSuppliers().add(parameter);
		assertSuperset(interfaceRealization.getTargets().contains(parameter));

		InstanceValue instanceValue = UML.createInstanceValue();
		assertValid(instanceValue);
		interfaceRealization.getSuppliers().add(instanceValue);
		assertSuperset(
			interfaceRealization.getTargets().contains(instanceValue));

		Trigger trigger = UML.createTrigger();
		assertValid(trigger);
		interfaceRealization.getSuppliers().add(trigger);
		assertSuperset(interfaceRealization.getTargets().contains(trigger));

		InteractionConstraint interactionConstraint = UML
			.createInteractionConstraint();
		assertValid(interactionConstraint);
		interfaceRealization.getSuppliers().add(interactionConstraint);
		assertSuperset(
			interfaceRealization.getTargets().contains(interactionConstraint));

		AssociationClass associationClass = UML.createAssociationClass();
		assertValid(associationClass);
		interfaceRealization.getSuppliers().add(associationClass);
		assertSuperset(
			interfaceRealization.getTargets().contains(associationClass));

		InteractionUse interactionUse = UML.createInteractionUse();
		assertValid(interactionUse);
		interfaceRealization.getSuppliers().add(interactionUse);
		assertSuperset(
			interfaceRealization.getTargets().contains(interactionUse));

		ClearStructuralFeatureAction clearStructuralFeatureAction = UML
			.createClearStructuralFeatureAction();
		assertValid(clearStructuralFeatureAction);
		interfaceRealization.getSuppliers().add(clearStructuralFeatureAction);
		assertSuperset(interfaceRealization.getTargets()
			.contains(clearStructuralFeatureAction));

		Interval interval = UML.createInterval();
		assertValid(interval);
		interfaceRealization.getSuppliers().add(interval);
		assertSuperset(interfaceRealization.getTargets().contains(interval));

		StructuredActivityNode structuredActivityNode = UML
			.createStructuredActivityNode();
		assertValid(structuredActivityNode);
		interfaceRealization.getSuppliers().add(structuredActivityNode);
		assertSuperset(
			interfaceRealization.getTargets().contains(structuredActivityNode));

		LiteralString literalString = UML.createLiteralString();
		assertValid(literalString);
		interfaceRealization.getSuppliers().add(literalString);
		assertSuperset(
			interfaceRealization.getTargets().contains(literalString));

		ValuePin valuePin = UML.createValuePin();
		assertValid(valuePin);
		interfaceRealization.getSuppliers().add(valuePin);
		assertSuperset(interfaceRealization.getTargets().contains(valuePin));

		InterfaceRealization interfaceRealization2 = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization2);
		interfaceRealization.getSuppliers().add(interfaceRealization2);
		assertSuperset(
			interfaceRealization.getTargets().contains(interfaceRealization2));

		ForkNode forkNode = UML.createForkNode();
		assertValid(forkNode);
		interfaceRealization.getSuppliers().add(forkNode);
		assertSuperset(interfaceRealization.getTargets().contains(forkNode));

		DecisionNode decisionNode = UML.createDecisionNode();
		assertValid(decisionNode);
		interfaceRealization.getSuppliers().add(decisionNode);
		assertSuperset(
			interfaceRealization.getTargets().contains(decisionNode));

		Actor actor = UML.createActor();
		assertValid(actor);
		interfaceRealization.getSuppliers().add(actor);
		assertSuperset(interfaceRealization.getTargets().contains(actor));

		TimeConstraint timeConstraint = UML.createTimeConstraint();
		assertValid(timeConstraint);
		interfaceRealization.getSuppliers().add(timeConstraint);
		assertSuperset(
			interfaceRealization.getTargets().contains(timeConstraint));

		Reception reception = UML.createReception();
		assertValid(reception);
		interfaceRealization.getSuppliers().add(reception);
		assertSuperset(interfaceRealization.getTargets().contains(reception));

		Pseudostate pseudostate = UML.createPseudostate();
		assertValid(pseudostate);
		interfaceRealization.getSuppliers().add(pseudostate);
		assertSuperset(interfaceRealization.getTargets().contains(pseudostate));

		DurationInterval durationInterval = UML.createDurationInterval();
		assertValid(durationInterval);
		interfaceRealization.getSuppliers().add(durationInterval);
		assertSuperset(
			interfaceRealization.getTargets().contains(durationInterval));

		Deployment deployment = UML.createDeployment();
		assertValid(deployment);
		interfaceRealization.getSuppliers().add(deployment);
		assertSuperset(interfaceRealization.getTargets().contains(deployment));

		ExtensionEnd extensionEnd = UML.createExtensionEnd();
		assertValid(extensionEnd);
		interfaceRealization.getSuppliers().add(extensionEnd);
		assertSuperset(
			interfaceRealization.getTargets().contains(extensionEnd));

		ConsiderIgnoreFragment considerIgnoreFragment = UML
			.createConsiderIgnoreFragment();
		assertValid(considerIgnoreFragment);
		interfaceRealization.getSuppliers().add(considerIgnoreFragment);
		assertSuperset(
			interfaceRealization.getTargets().contains(considerIgnoreFragment));

		ConditionalNode conditionalNode = UML.createConditionalNode();
		assertValid(conditionalNode);
		interfaceRealization.getSuppliers().add(conditionalNode);
		assertSuperset(
			interfaceRealization.getTargets().contains(conditionalNode));

		ReadExtentAction readExtentAction = UML.createReadExtentAction();
		assertValid(readExtentAction);
		interfaceRealization.getSuppliers().add(readExtentAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(readExtentAction));

		ActionInputPin actionInputPin = UML.createActionInputPin();
		assertValid(actionInputPin);
		interfaceRealization.getSuppliers().add(actionInputPin);
		assertSuperset(
			interfaceRealization.getTargets().contains(actionInputPin));

		Artifact artifact = UML.createArtifact();
		assertValid(artifact);
		interfaceRealization.getSuppliers().add(artifact);
		assertSuperset(interfaceRealization.getTargets().contains(artifact));

		InformationFlow informationFlow = UML.createInformationFlow();
		assertValid(informationFlow);
		interfaceRealization.getSuppliers().add(informationFlow);
		assertSuperset(
			interfaceRealization.getTargets().contains(informationFlow));

		ClearVariableAction clearVariableAction = UML
			.createClearVariableAction();
		assertValid(clearVariableAction);
		interfaceRealization.getSuppliers().add(clearVariableAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(clearVariableAction));

		CreateLinkAction createLinkAction = UML.createCreateLinkAction();
		assertValid(createLinkAction);
		interfaceRealization.getSuppliers().add(createLinkAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(createLinkAction));

		SignalEvent signalEvent = UML.createSignalEvent();
		assertValid(signalEvent);
		interfaceRealization.getSuppliers().add(signalEvent);
		assertSuperset(interfaceRealization.getTargets().contains(signalEvent));

		ConnectionPointReference connectionPointReference = UML
			.createConnectionPointReference();
		assertValid(connectionPointReference);
		interfaceRealization.getSuppliers().add(connectionPointReference);
		assertSuperset(interfaceRealization.getTargets()
			.contains(connectionPointReference));

		ReclassifyObjectAction reclassifyObjectAction = UML
			.createReclassifyObjectAction();
		assertValid(reclassifyObjectAction);
		interfaceRealization.getSuppliers().add(reclassifyObjectAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(reclassifyObjectAction));

		Usage usage = UML.createUsage();
		assertValid(usage);
		interfaceRealization.getSuppliers().add(usage);
		assertSuperset(interfaceRealization.getTargets().contains(usage));

		DataStoreNode dataStoreNode = UML.createDataStoreNode();
		assertValid(dataStoreNode);
		interfaceRealization.getSuppliers().add(dataStoreNode);
		assertSuperset(
			interfaceRealization.getTargets().contains(dataStoreNode));

		ExecutionEnvironment executionEnvironment = UML
			.createExecutionEnvironment();
		assertValid(executionEnvironment);
		interfaceRealization.getSuppliers().add(executionEnvironment);
		assertSuperset(
			interfaceRealization.getTargets().contains(executionEnvironment));

		SendObjectAction sendObjectAction = UML.createSendObjectAction();
		assertValid(sendObjectAction);
		interfaceRealization.getSuppliers().add(sendObjectAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(sendObjectAction));

		ControlFlow controlFlow = UML.createControlFlow();
		assertValid(controlFlow);
		interfaceRealization.getSuppliers().add(controlFlow);
		assertSuperset(interfaceRealization.getTargets().contains(controlFlow));

		DeploymentSpecification deploymentSpecification = UML
			.createDeploymentSpecification();
		assertValid(deploymentSpecification);
		interfaceRealization.getSuppliers().add(deploymentSpecification);
		assertSuperset(interfaceRealization.getTargets()
			.contains(deploymentSpecification));

		PartDecomposition partDecomposition = UML.createPartDecomposition();
		assertValid(partDecomposition);
		interfaceRealization.getSuppliers().add(partDecomposition);
		assertSuperset(
			interfaceRealization.getTargets().contains(partDecomposition));

		DestroyLinkAction destroyLinkAction = UML.createDestroyLinkAction();
		assertValid(destroyLinkAction);
		interfaceRealization.getSuppliers().add(destroyLinkAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(destroyLinkAction));

		Realization realization = UML.createRealization();
		assertValid(realization);
		interfaceRealization.getSuppliers().add(realization);
		assertSuperset(interfaceRealization.getTargets().contains(realization));

		ExpansionNode expansionNode = UML.createExpansionNode();
		assertValid(expansionNode);
		interfaceRealization.getSuppliers().add(expansionNode);
		assertSuperset(
			interfaceRealization.getTargets().contains(expansionNode));

		TestIdentityAction testIdentityAction = UML.createTestIdentityAction();
		assertValid(testIdentityAction);
		interfaceRealization.getSuppliers().add(testIdentityAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(testIdentityAction));

		Association association = UML.createAssociation();
		assertValid(association);
		interfaceRealization.getSuppliers().add(association);
		assertSuperset(interfaceRealization.getTargets().contains(association));

		TimeInterval timeInterval = UML.createTimeInterval();
		assertValid(timeInterval);
		interfaceRealization.getSuppliers().add(timeInterval);
		assertSuperset(
			interfaceRealization.getTargets().contains(timeInterval));

		DataType dataType = UML.createDataType();
		assertValid(dataType);
		interfaceRealization.getSuppliers().add(dataType);
		assertSuperset(interfaceRealization.getTargets().contains(dataType));

		OutputPin outputPin = UML.createOutputPin();
		assertValid(outputPin);
		interfaceRealization.getSuppliers().add(outputPin);
		assertSuperset(interfaceRealization.getTargets().contains(outputPin));

		Substitution substitution = UML.createSubstitution();
		assertValid(substitution);
		interfaceRealization.getSuppliers().add(substitution);
		assertSuperset(
			interfaceRealization.getTargets().contains(substitution));

		Include include = UML.createInclude();
		assertValid(include);
		interfaceRealization.getSuppliers().add(include);
		assertSuperset(interfaceRealization.getTargets().contains(include));

		Extend extend = UML.createExtend();
		assertValid(extend);
		interfaceRealization.getSuppliers().add(extend);
		assertSuperset(interfaceRealization.getTargets().contains(extend));

		BroadcastSignalAction broadcastSignalAction = UML
			.createBroadcastSignalAction();
		assertValid(broadcastSignalAction);
		interfaceRealization.getSuppliers().add(broadcastSignalAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(broadcastSignalAction));

		LiteralBoolean literalBoolean = UML.createLiteralBoolean();
		assertValid(literalBoolean);
		interfaceRealization.getSuppliers().add(literalBoolean);
		assertSuperset(
			interfaceRealization.getTargets().contains(literalBoolean));

		FinalState finalState = UML.createFinalState();
		assertValid(finalState);
		interfaceRealization.getSuppliers().add(finalState);
		assertSuperset(interfaceRealization.getTargets().contains(finalState));

		RaiseExceptionAction raiseExceptionAction = UML
			.createRaiseExceptionAction();
		assertValid(raiseExceptionAction);
		interfaceRealization.getSuppliers().add(raiseExceptionAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(raiseExceptionAction));

		DurationConstraint durationConstraint = UML.createDurationConstraint();
		assertValid(durationConstraint);
		interfaceRealization.getSuppliers().add(durationConstraint);
		assertSuperset(
			interfaceRealization.getTargets().contains(durationConstraint));

		ActivityFinalNode activityFinalNode = UML.createActivityFinalNode();
		assertValid(activityFinalNode);
		interfaceRealization.getSuppliers().add(activityFinalNode);
		assertSuperset(
			interfaceRealization.getTargets().contains(activityFinalNode));

		LiteralNull literalNull = UML.createLiteralNull();
		assertValid(literalNull);
		interfaceRealization.getSuppliers().add(literalNull);
		assertSuperset(interfaceRealization.getTargets().contains(literalNull));

		CallOperationAction callOperationAction = UML
			.createCallOperationAction();
		assertValid(callOperationAction);
		interfaceRealization.getSuppliers().add(callOperationAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(callOperationAction));

		ProtocolStateMachine protocolStateMachine = UML
			.createProtocolStateMachine();
		assertValid(protocolStateMachine);
		interfaceRealization.getSuppliers().add(protocolStateMachine);
		assertSuperset(
			interfaceRealization.getTargets().contains(protocolStateMachine));

		LoopNode loopNode = UML.createLoopNode();
		assertValid(loopNode);
		interfaceRealization.getSuppliers().add(loopNode);
		assertSuperset(interfaceRealization.getTargets().contains(loopNode));

		ParameterSet parameterSet = UML.createParameterSet();
		assertValid(parameterSet);
		interfaceRealization.getSuppliers().add(parameterSet);
		assertSuperset(
			interfaceRealization.getTargets().contains(parameterSet));

		ValueSpecificationAction valueSpecificationAction = UML
			.createValueSpecificationAction();
		assertValid(valueSpecificationAction);
		interfaceRealization.getSuppliers().add(valueSpecificationAction);
		assertSuperset(interfaceRealization.getTargets()
			.contains(valueSpecificationAction));

		Node node = UML.createNode();
		assertValid(node);
		interfaceRealization.getSuppliers().add(node);
		assertSuperset(interfaceRealization.getTargets().contains(node));

		SequenceNode sequenceNode = UML.createSequenceNode();
		assertValid(sequenceNode);
		interfaceRealization.getSuppliers().add(sequenceNode);
		assertSuperset(
			interfaceRealization.getTargets().contains(sequenceNode));

		Constraint constraint = UML.createConstraint();
		assertValid(constraint);
		interfaceRealization.getSuppliers().add(constraint);
		assertSuperset(interfaceRealization.getTargets().contains(constraint));

		DestroyObjectAction destroyObjectAction = UML
			.createDestroyObjectAction();
		assertValid(destroyObjectAction);
		interfaceRealization.getSuppliers().add(destroyObjectAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(destroyObjectAction));

		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		interfaceRealization.getSuppliers().add(stateMachine);
		assertSuperset(
			interfaceRealization.getTargets().contains(stateMachine));

		EnumerationLiteral enumerationLiteral = UML.createEnumerationLiteral();
		assertValid(enumerationLiteral);
		interfaceRealization.getSuppliers().add(enumerationLiteral);
		assertSuperset(
			interfaceRealization.getTargets().contains(enumerationLiteral));

		ActionExecutionSpecification actionExecutionSpecification = UML
			.createActionExecutionSpecification();
		assertValid(actionExecutionSpecification);
		interfaceRealization.getSuppliers().add(actionExecutionSpecification);
		assertSuperset(interfaceRealization.getTargets()
			.contains(actionExecutionSpecification));

		FunctionBehavior functionBehavior = UML.createFunctionBehavior();
		assertValid(functionBehavior);
		interfaceRealization.getSuppliers().add(functionBehavior);
		assertSuperset(
			interfaceRealization.getTargets().contains(functionBehavior));

		Interface interface_ = UML.createInterface();
		assertValid(interface_);
		interfaceRealization.getSuppliers().add(interface_);
		assertSuperset(interfaceRealization.getTargets().contains(interface_));

		InstanceSpecification instanceSpecification = UML
			.createInstanceSpecification();
		assertValid(instanceSpecification);
		interfaceRealization.getSuppliers().add(instanceSpecification);
		assertSuperset(
			interfaceRealization.getTargets().contains(instanceSpecification));

		StartClassifierBehaviorAction startClassifierBehaviorAction = UML
			.createStartClassifierBehaviorAction();
		assertValid(startClassifierBehaviorAction);
		interfaceRealization.getSuppliers().add(startClassifierBehaviorAction);
		assertSuperset(interfaceRealization.getTargets()
			.contains(startClassifierBehaviorAction));

		Port port = UML.createPort();
		assertValid(port);
		interfaceRealization.getSuppliers().add(port);
		assertSuperset(interfaceRealization.getTargets().contains(port));

		RemoveVariableValueAction removeVariableValueAction = UML
			.createRemoveVariableValueAction();
		assertValid(removeVariableValueAction);
		interfaceRealization.getSuppliers().add(removeVariableValueAction);
		assertSuperset(interfaceRealization.getTargets()
			.contains(removeVariableValueAction));

		InformationItem informationItem = UML.createInformationItem();
		assertValid(informationItem);
		interfaceRealization.getSuppliers().add(informationItem);
		assertSuperset(
			interfaceRealization.getTargets().contains(informationItem));

		LiteralReal literalReal = UML.createLiteralReal();
		assertValid(literalReal);
		interfaceRealization.getSuppliers().add(literalReal);
		assertSuperset(interfaceRealization.getTargets().contains(literalReal));

		RedefinableTemplateSignature redefinableTemplateSignature = UML
			.createRedefinableTemplateSignature();
		assertValid(redefinableTemplateSignature);
		interfaceRealization.getSuppliers().add(redefinableTemplateSignature);
		assertSuperset(interfaceRealization.getTargets()
			.contains(redefinableTemplateSignature));

		ExecutionOccurrenceSpecification executionOccurrenceSpecification = UML
			.createExecutionOccurrenceSpecification();
		assertValid(executionOccurrenceSpecification);
		interfaceRealization.getSuppliers()
			.add(executionOccurrenceSpecification);
		assertSuperset(interfaceRealization.getTargets()
			.contains(executionOccurrenceSpecification));

		Duration duration = UML.createDuration();
		assertValid(duration);
		interfaceRealization.getSuppliers().add(duration);
		assertSuperset(interfaceRealization.getTargets().contains(duration));

		org.eclipse.uml2.uml.Package package_ = UML.createPackage();
		assertValid(package_);
		interfaceRealization.getSuppliers().add(package_);
		assertSuperset(interfaceRealization.getTargets().contains(package_));

		Variable variable = UML.createVariable();
		assertValid(variable);
		interfaceRealization.getSuppliers().add(variable);
		assertSuperset(interfaceRealization.getTargets().contains(variable));

		DestructionOccurrenceSpecification destructionOccurrenceSpecification = UML
			.createDestructionOccurrenceSpecification();
		assertValid(destructionOccurrenceSpecification);
		interfaceRealization.getSuppliers()
			.add(destructionOccurrenceSpecification);
		assertSuperset(interfaceRealization.getTargets()
			.contains(destructionOccurrenceSpecification));

		Lifeline lifeline = UML.createLifeline();
		assertValid(lifeline);
		interfaceRealization.getSuppliers().add(lifeline);
		assertSuperset(interfaceRealization.getTargets().contains(lifeline));

		TimeObservation timeObservation = UML.createTimeObservation();
		assertValid(timeObservation);
		interfaceRealization.getSuppliers().add(timeObservation);
		assertSuperset(
			interfaceRealization.getTargets().contains(timeObservation));

		ReplyAction replyAction = UML.createReplyAction();
		assertValid(replyAction);
		interfaceRealization.getSuppliers().add(replyAction);
		assertSuperset(interfaceRealization.getTargets().contains(replyAction));

		Gate gate = UML.createGate();
		assertValid(gate);
		interfaceRealization.getSuppliers().add(gate);
		assertSuperset(interfaceRealization.getTargets().contains(gate));

		Property property = UML.createProperty();
		assertValid(property);
		interfaceRealization.getSuppliers().add(property);
		assertSuperset(interfaceRealization.getTargets().contains(property));

		TimeExpression timeExpression = UML.createTimeExpression();
		assertValid(timeExpression);
		interfaceRealization.getSuppliers().add(timeExpression);
		assertSuperset(
			interfaceRealization.getTargets().contains(timeExpression));

		Device device = UML.createDevice();
		assertValid(device);
		interfaceRealization.getSuppliers().add(device);
		assertSuperset(interfaceRealization.getTargets().contains(device));

		FlowFinalNode flowFinalNode = UML.createFlowFinalNode();
		assertValid(flowFinalNode);
		interfaceRealization.getSuppliers().add(flowFinalNode);
		assertSuperset(
			interfaceRealization.getTargets().contains(flowFinalNode));

		ExpansionRegion expansionRegion = UML.createExpansionRegion();
		assertValid(expansionRegion);
		interfaceRealization.getSuppliers().add(expansionRegion);
		assertSuperset(
			interfaceRealization.getTargets().contains(expansionRegion));

		Abstraction abstraction = UML.createAbstraction();
		assertValid(abstraction);
		interfaceRealization.getSuppliers().add(abstraction);
		assertSuperset(interfaceRealization.getTargets().contains(abstraction));

		StartObjectBehaviorAction startObjectBehaviorAction = UML
			.createStartObjectBehaviorAction();
		assertValid(startObjectBehaviorAction);
		interfaceRealization.getSuppliers().add(startObjectBehaviorAction);
		assertSuperset(interfaceRealization.getTargets()
			.contains(startObjectBehaviorAction));

		Enumeration enumeration = UML.createEnumeration();
		assertValid(enumeration);
		interfaceRealization.getSuppliers().add(enumeration);
		assertSuperset(interfaceRealization.getTargets().contains(enumeration));

		PrimitiveType primitiveType = UML.createPrimitiveType();
		assertValid(primitiveType);
		interfaceRealization.getSuppliers().add(primitiveType);
		assertSuperset(
			interfaceRealization.getTargets().contains(primitiveType));

		Profile profile = UML.createProfile();
		assertValid(profile);
		interfaceRealization.getSuppliers().add(profile);
		assertSuperset(interfaceRealization.getTargets().contains(profile));

		Message message = UML.createMessage();
		assertValid(message);
		interfaceRealization.getSuppliers().add(message);
		assertSuperset(interfaceRealization.getTargets().contains(message));

		GeneralizationSet generalizationSet = UML.createGeneralizationSet();
		assertValid(generalizationSet);
		interfaceRealization.getSuppliers().add(generalizationSet);
		assertSuperset(
			interfaceRealization.getTargets().contains(generalizationSet));

		Continuation continuation = UML.createContinuation();
		assertValid(continuation);
		interfaceRealization.getSuppliers().add(continuation);
		assertSuperset(
			interfaceRealization.getTargets().contains(continuation));

		Signal signal = UML.createSignal();
		assertValid(signal);
		interfaceRealization.getSuppliers().add(signal);
		assertSuperset(interfaceRealization.getTargets().contains(signal));

		CallBehaviorAction callBehaviorAction = UML.createCallBehaviorAction();
		assertValid(callBehaviorAction);
		interfaceRealization.getSuppliers().add(callBehaviorAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(callBehaviorAction));

		ObjectFlow objectFlow = UML.createObjectFlow();
		assertValid(objectFlow);
		interfaceRealization.getSuppliers().add(objectFlow);
		assertSuperset(interfaceRealization.getTargets().contains(objectFlow));

		StateInvariant stateInvariant = UML.createStateInvariant();
		assertValid(stateInvariant);
		interfaceRealization.getSuppliers().add(stateInvariant);
		assertSuperset(
			interfaceRealization.getTargets().contains(stateInvariant));

		ReadIsClassifiedObjectAction readIsClassifiedObjectAction = UML
			.createReadIsClassifiedObjectAction();
		assertValid(readIsClassifiedObjectAction);
		interfaceRealization.getSuppliers().add(readIsClassifiedObjectAction);
		assertSuperset(interfaceRealization.getTargets()
			.contains(readIsClassifiedObjectAction));

		ActivityParameterNode activityParameterNode = UML
			.createActivityParameterNode();
		assertValid(activityParameterNode);
		interfaceRealization.getSuppliers().add(activityParameterNode);
		assertSuperset(
			interfaceRealization.getTargets().contains(activityParameterNode));

		AddStructuralFeatureValueAction addStructuralFeatureValueAction = UML
			.createAddStructuralFeatureValueAction();
		assertValid(addStructuralFeatureValueAction);
		interfaceRealization.getSuppliers()
			.add(addStructuralFeatureValueAction);
		assertSuperset(interfaceRealization.getTargets()
			.contains(addStructuralFeatureValueAction));

		ReadVariableAction readVariableAction = UML.createReadVariableAction();
		assertValid(readVariableAction);
		interfaceRealization.getSuppliers().add(readVariableAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(readVariableAction));

		InterruptibleActivityRegion interruptibleActivityRegion = UML
			.createInterruptibleActivityRegion();
		assertValid(interruptibleActivityRegion);
		interfaceRealization.getSuppliers().add(interruptibleActivityRegion);
		assertSuperset(interfaceRealization.getTargets()
			.contains(interruptibleActivityRegion));

		RemoveStructuralFeatureValueAction removeStructuralFeatureValueAction = UML
			.createRemoveStructuralFeatureValueAction();
		assertValid(removeStructuralFeatureValueAction);
		interfaceRealization.getSuppliers()
			.add(removeStructuralFeatureValueAction);
		assertSuperset(interfaceRealization.getTargets()
			.contains(removeStructuralFeatureValueAction));

		OpaqueExpression opaqueExpression = UML.createOpaqueExpression();
		assertValid(opaqueExpression);
		interfaceRealization.getSuppliers().add(opaqueExpression);
		assertSuperset(
			interfaceRealization.getTargets().contains(opaqueExpression));

		TimeEvent timeEvent = UML.createTimeEvent();
		assertValid(timeEvent);
		interfaceRealization.getSuppliers().add(timeEvent);
		assertSuperset(interfaceRealization.getTargets().contains(timeEvent));

		GeneralOrdering generalOrdering = UML.createGeneralOrdering();
		assertValid(generalOrdering);
		interfaceRealization.getSuppliers().add(generalOrdering);
		assertSuperset(
			interfaceRealization.getTargets().contains(generalOrdering));

		Region region = UML.createRegion();
		assertValid(region);
		interfaceRealization.getSuppliers().add(region);
		assertSuperset(interfaceRealization.getTargets().contains(region));

		Transition transition = UML.createTransition();
		assertValid(transition);
		interfaceRealization.getSuppliers().add(transition);
		assertSuperset(interfaceRealization.getTargets().contains(transition));

		AnyReceiveEvent anyReceiveEvent = UML.createAnyReceiveEvent();
		assertValid(anyReceiveEvent);
		interfaceRealization.getSuppliers().add(anyReceiveEvent);
		assertSuperset(
			interfaceRealization.getTargets().contains(anyReceiveEvent));

		MessageOccurrenceSpecification messageOccurrenceSpecification = UML
			.createMessageOccurrenceSpecification();
		assertValid(messageOccurrenceSpecification);
		interfaceRealization.getSuppliers().add(messageOccurrenceSpecification);
		assertSuperset(interfaceRealization.getTargets()
			.contains(messageOccurrenceSpecification));

		LiteralInteger literalInteger = UML.createLiteralInteger();
		assertValid(literalInteger);
		interfaceRealization.getSuppliers().add(literalInteger);
		assertSuperset(
			interfaceRealization.getTargets().contains(literalInteger));

		ReduceAction reduceAction = UML.createReduceAction();
		assertValid(reduceAction);
		interfaceRealization.getSuppliers().add(reduceAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(reduceAction));

		AcceptEventAction acceptEventAction = UML.createAcceptEventAction();
		assertValid(acceptEventAction);
		interfaceRealization.getSuppliers().add(acceptEventAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(acceptEventAction));

		InitialNode initialNode = UML.createInitialNode();
		assertValid(initialNode);
		interfaceRealization.getSuppliers().add(initialNode);
		assertSuperset(interfaceRealization.getTargets().contains(initialNode));

		CentralBufferNode centralBufferNode = UML.createCentralBufferNode();
		assertValid(centralBufferNode);
		interfaceRealization.getSuppliers().add(centralBufferNode);
		assertSuperset(
			interfaceRealization.getTargets().contains(centralBufferNode));

		CombinedFragment combinedFragment = UML.createCombinedFragment();
		assertValid(combinedFragment);
		interfaceRealization.getSuppliers().add(combinedFragment);
		assertSuperset(
			interfaceRealization.getTargets().contains(combinedFragment));

		IntervalConstraint intervalConstraint = UML.createIntervalConstraint();
		assertValid(intervalConstraint);
		interfaceRealization.getSuppliers().add(intervalConstraint);
		assertSuperset(
			interfaceRealization.getTargets().contains(intervalConstraint));

		Extension extension = UML.createExtension();
		assertValid(extension);
		interfaceRealization.getSuppliers().add(extension);
		assertSuperset(interfaceRealization.getTargets().contains(extension));

		OccurrenceSpecification occurrenceSpecification = UML
			.createOccurrenceSpecification();
		assertValid(occurrenceSpecification);
		interfaceRealization.getSuppliers().add(occurrenceSpecification);
		assertSuperset(interfaceRealization.getTargets()
			.contains(occurrenceSpecification));

		ExtensionPoint extensionPoint = UML.createExtensionPoint();
		assertValid(extensionPoint);
		interfaceRealization.getSuppliers().add(extensionPoint);
		assertSuperset(
			interfaceRealization.getTargets().contains(extensionPoint));

		Dependency dependency = UML.createDependency();
		assertValid(dependency);
		interfaceRealization.getSuppliers().add(dependency);
		assertSuperset(interfaceRealization.getTargets().contains(dependency));

		Connector connector = UML.createConnector();
		assertValid(connector);
		interfaceRealization.getSuppliers().add(connector);
		assertSuperset(interfaceRealization.getTargets().contains(connector));

		Expression expression = UML.createExpression();
		assertValid(expression);
		interfaceRealization.getSuppliers().add(expression);
		assertSuperset(interfaceRealization.getTargets().contains(expression));

		ComponentRealization componentRealization = UML
			.createComponentRealization();
		assertValid(componentRealization);
		interfaceRealization.getSuppliers().add(componentRealization);
		assertSuperset(
			interfaceRealization.getTargets().contains(componentRealization));

		org.eclipse.uml2.uml.Class class_ = UML.createClass();
		assertValid(class_);
		interfaceRealization.getSuppliers().add(class_);
		assertSuperset(interfaceRealization.getTargets().contains(class_));

		State state = UML.createState();
		assertValid(state);
		interfaceRealization.getSuppliers().add(state);
		assertSuperset(interfaceRealization.getTargets().contains(state));

		ProtocolTransition protocolTransition = UML.createProtocolTransition();
		assertValid(protocolTransition);
		interfaceRealization.getSuppliers().add(protocolTransition);
		assertSuperset(
			interfaceRealization.getTargets().contains(protocolTransition));

		BehaviorExecutionSpecification behaviorExecutionSpecification = UML
			.createBehaviorExecutionSpecification();
		assertValid(behaviorExecutionSpecification);
		interfaceRealization.getSuppliers().add(behaviorExecutionSpecification);
		assertSuperset(interfaceRealization.getTargets()
			.contains(behaviorExecutionSpecification));

		CollaborationUse collaborationUse = UML.createCollaborationUse();
		assertValid(collaborationUse);
		interfaceRealization.getSuppliers().add(collaborationUse);
		assertSuperset(
			interfaceRealization.getTargets().contains(collaborationUse));

		InteractionOperand interactionOperand = UML.createInteractionOperand();
		assertValid(interactionOperand);
		interfaceRealization.getSuppliers().add(interactionOperand);
		assertSuperset(
			interfaceRealization.getTargets().contains(interactionOperand));

		AcceptCallAction acceptCallAction = UML.createAcceptCallAction();
		assertValid(acceptCallAction);
		interfaceRealization.getSuppliers().add(acceptCallAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(acceptCallAction));

		AddVariableValueAction addVariableValueAction = UML
			.createAddVariableValueAction();
		assertValid(addVariableValueAction);
		interfaceRealization.getSuppliers().add(addVariableValueAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(addVariableValueAction));

		ReadLinkObjectEndAction readLinkObjectEndAction = UML
			.createReadLinkObjectEndAction();
		assertValid(readLinkObjectEndAction);
		interfaceRealization.getSuppliers().add(readLinkObjectEndAction);
		assertSuperset(interfaceRealization.getTargets()
			.contains(readLinkObjectEndAction));

		UseCase useCase = UML.createUseCase();
		assertValid(useCase);
		interfaceRealization.getSuppliers().add(useCase);
		assertSuperset(interfaceRealization.getTargets().contains(useCase));

		UnmarshallAction unmarshallAction = UML.createUnmarshallAction();
		assertValid(unmarshallAction);
		interfaceRealization.getSuppliers().add(unmarshallAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(unmarshallAction));

		OpaqueAction opaqueAction = UML.createOpaqueAction();
		assertValid(opaqueAction);
		interfaceRealization.getSuppliers().add(opaqueAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(opaqueAction));

		StringExpression stringExpression = UML.createStringExpression();
		assertValid(stringExpression);
		interfaceRealization.getSuppliers().add(stringExpression);
		assertSuperset(
			interfaceRealization.getTargets().contains(stringExpression));

		MergeNode mergeNode = UML.createMergeNode();
		assertValid(mergeNode);
		interfaceRealization.getSuppliers().add(mergeNode);
		assertSuperset(interfaceRealization.getTargets().contains(mergeNode));

		ChangeEvent changeEvent = UML.createChangeEvent();
		assertValid(changeEvent);
		interfaceRealization.getSuppliers().add(changeEvent);
		assertSuperset(interfaceRealization.getTargets().contains(changeEvent));

		CreateObjectAction createObjectAction = UML.createCreateObjectAction();
		assertValid(createObjectAction);
		interfaceRealization.getSuppliers().add(createObjectAction);
		assertSuperset(
			interfaceRealization.getTargets().contains(createObjectAction));

		Stereotype stereotype = UML.createStereotype();
		assertValid(stereotype);
		interfaceRealization.getSuppliers().add(stereotype);
		assertSuperset(interfaceRealization.getTargets().contains(stereotype));

		ReadStructuralFeatureAction readStructuralFeatureAction = UML
			.createReadStructuralFeatureAction();
		assertValid(readStructuralFeatureAction);
		interfaceRealization.getSuppliers().add(readStructuralFeatureAction);
		assertSuperset(interfaceRealization.getTargets()
			.contains(readStructuralFeatureAction));

		Collaboration collaboration = UML.createCollaboration();
		assertValid(collaboration);
		interfaceRealization.getSuppliers().add(collaboration);
		assertSuperset(
			interfaceRealization.getTargets().contains(collaboration));
	}

	public void testMapping() {
		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);

		OpaqueExpression opaqueExpression = UML.createOpaqueExpression();
		assertValid(opaqueExpression);
		interfaceRealization.setMapping(opaqueExpression);
		assertSuperset(
			interfaceRealization.getOwnedElements().contains(opaqueExpression));
	}

	public void testContract() {
		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);

		Interface interface_ = UML.createInterface();
		assertValid(interface_);
		interfaceRealization.setContract(interface_);
		assertSuperset(
			interfaceRealization.getSuppliers().contains(interface_));
	}

	public void testImplementingClassifier() {
		InterfaceRealization interfaceRealization = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization);

		FunctionBehavior functionBehavior = UML.createFunctionBehavior();
		assertValid(functionBehavior);
		interfaceRealization.setImplementingClassifier(functionBehavior);
		assertSuperset(
			interfaceRealization.getClients().contains(functionBehavior));
		assertSuperset(interfaceRealization.getOwner() == functionBehavior);

		Activity activity = UML.createActivity();
		assertValid(activity);
		interfaceRealization.setImplementingClassifier(activity);
		assertSuperset(interfaceRealization.getClients().contains(activity));
		assertSuperset(interfaceRealization.getOwner() == activity);

		InterfaceRealization interfaceRealization2 = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization2);

		AssociationClass associationClass = UML.createAssociationClass();
		assertValid(associationClass);
		interfaceRealization2.setImplementingClassifier(associationClass);
		assertSuperset(
			interfaceRealization2.getClients().contains(associationClass));
		assertSuperset(interfaceRealization2.getOwner() == associationClass);

		org.eclipse.uml2.uml.Class class_ = UML.createClass();
		assertValid(class_);
		interfaceRealization2.setImplementingClassifier(class_);
		assertSuperset(interfaceRealization2.getClients().contains(class_));
		assertSuperset(interfaceRealization2.getOwner() == class_);

		InterfaceRealization interfaceRealization3 = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization3);

		ExecutionEnvironment executionEnvironment = UML
			.createExecutionEnvironment();
		assertValid(executionEnvironment);
		interfaceRealization3.setImplementingClassifier(executionEnvironment);
		assertSuperset(
			interfaceRealization3.getClients().contains(executionEnvironment));
		assertSuperset(
			interfaceRealization3.getOwner() == executionEnvironment);

		Component component = UML.createComponent();
		assertValid(component);
		interfaceRealization3.setImplementingClassifier(component);
		assertSuperset(interfaceRealization3.getClients().contains(component));
		assertSuperset(interfaceRealization3.getOwner() == component);

		InterfaceRealization interfaceRealization4 = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization4);

		Actor actor = UML.createActor();
		assertValid(actor);
		interfaceRealization4.setImplementingClassifier(actor);
		assertSuperset(interfaceRealization4.getClients().contains(actor));
		assertSuperset(interfaceRealization4.getOwner() == actor);

		ProtocolStateMachine protocolStateMachine = UML
			.createProtocolStateMachine();
		assertValid(protocolStateMachine);
		interfaceRealization4.setImplementingClassifier(protocolStateMachine);
		assertSuperset(
			interfaceRealization4.getClients().contains(protocolStateMachine));
		assertSuperset(
			interfaceRealization4.getOwner() == protocolStateMachine);

		InterfaceRealization interfaceRealization5 = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization5);

		Interaction interaction = UML.createInteraction();
		assertValid(interaction);
		interfaceRealization5.setImplementingClassifier(interaction);
		assertSuperset(
			interfaceRealization5.getClients().contains(interaction));
		assertSuperset(interfaceRealization5.getOwner() == interaction);

		UseCase useCase = UML.createUseCase();
		assertValid(useCase);
		interfaceRealization5.setImplementingClassifier(useCase);
		assertSuperset(interfaceRealization5.getClients().contains(useCase));
		assertSuperset(interfaceRealization5.getOwner() == useCase);

		InterfaceRealization interfaceRealization6 = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization6);

		OpaqueBehavior opaqueBehavior = UML.createOpaqueBehavior();
		assertValid(opaqueBehavior);
		interfaceRealization6.setImplementingClassifier(opaqueBehavior);
		assertSuperset(
			interfaceRealization6.getClients().contains(opaqueBehavior));
		assertSuperset(interfaceRealization6.getOwner() == opaqueBehavior);

		Node node = UML.createNode();
		assertValid(node);
		interfaceRealization6.setImplementingClassifier(node);
		assertSuperset(interfaceRealization6.getClients().contains(node));
		assertSuperset(interfaceRealization6.getOwner() == node);

		InterfaceRealization interfaceRealization7 = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization7);

		Stereotype stereotype = UML.createStereotype();
		assertValid(stereotype);
		interfaceRealization7.setImplementingClassifier(stereotype);
		assertSuperset(interfaceRealization7.getClients().contains(stereotype));
		assertSuperset(interfaceRealization7.getOwner() == stereotype);

		StateMachine stateMachine = UML.createStateMachine();
		assertValid(stateMachine);
		interfaceRealization7.setImplementingClassifier(stateMachine);
		assertSuperset(
			interfaceRealization7.getClients().contains(stateMachine));
		assertSuperset(interfaceRealization7.getOwner() == stateMachine);

		InterfaceRealization interfaceRealization8 = UML
			.createInterfaceRealization();
		assertValid(interfaceRealization8);

		Device device = UML.createDevice();
		assertValid(device);
		interfaceRealization8.setImplementingClassifier(device);
		assertSuperset(interfaceRealization8.getClients().contains(device));
		assertSuperset(interfaceRealization8.getOwner() == device);

		Collaboration collaboration = UML.createCollaboration();
		assertValid(collaboration);
		interfaceRealization8.setImplementingClassifier(collaboration);
		assertSuperset(
			interfaceRealization8.getClients().contains(collaboration));
		assertSuperset(interfaceRealization8.getOwner() == collaboration);
	}

}