public void ShouldNotRejectSameLink()
		{
			DataContract source = new DataContract(Store);
			DataContract target = new DataContract(Store);
			DataContractBaseCanBeContainedOnContracts link = new DataContractBaseCanBeContainedOnContracts(source, target);
			ModelElementReference dataElement = new ModelElementReference(Store);
			dataElement.SetLinkedElement(link.Id);
			source.DataMembers.Add(dataElement);
			bool result = AggregationConnectionBuilder.CanAcceptSourceAndTarget(source, target);

			Assert.IsTrue(result);
		}
		private List<DataMember> LoadLinkedElements(DataContractBase sourceElement)
		{
			DataContract targetElement = new DataContract(Store);
			targetElement.Name = DataContractLinkedElementType;
			DataContractBaseCanBeContainedOnContracts link = new DataContractBaseCanBeContainedOnContracts(sourceElement, targetElement);

			List<DataMember> dataElements = new List<DataMember>();
			ModelElementReference element1 = new ModelElementReference(Store);
			element1.Name = sourceElement.Name;
			element1.Type = sourceElement.Name;
			element1.SetLinkedElement(link.Id);

			dataElements.Add(element1);
			return dataElements;
		}
		public void ShouldGetNewNameOnMultipleTargets()
		{
			DataContract source = new DataContract(Store);
			source.Name = "Source";
			DataContract target = new DataContract(Store);
			target.Name = "Target";
			DataContractBaseCanBeContainedOnContracts link = new DataContractBaseCanBeContainedOnContracts(source, target);
			ModelElementReference dataElement = new ModelElementReference(Store);
			dataElement.Name = "DcdeName";
			dataElement.SetLinkedElement(link.Id);
			source.DataMembers.Add(dataElement);
			AggregationConnectionBuilder.Connect(source, target);

			Assert.AreEqual(1, target.DataMembers.Count);
			dataElement = (ModelElementReference)target.DataMembers[0];
			Assert.AreEqual("Source", dataElement.Name);

			AggregationConnectionBuilder.Connect(source, target);

			Assert.AreEqual(2, target.DataMembers.Count);
			dataElement = (ModelElementReference)target.DataMembers[1];
			Assert.AreEqual("Source1", dataElement.Name);

			AggregationConnectionBuilder.Connect(source, target);

			Assert.AreEqual(3, target.DataMembers.Count);
			dataElement = (ModelElementReference)target.DataMembers[2];
			Assert.AreEqual("Source2", dataElement.Name);
		}
		public static ElementLink Connect(ModelElement source, ModelElement target, string targetDataElementName)
		{
            Guard.ArgumentNotNull(source, "source");
            Guard.ArgumentNotNull(target, "target");

			if(CanAcceptSourceAndTarget(source, target))
			{
				if(source is DataContractBase)
				{
					if(target is DataContract)
					{
						DataContractBase sourceAccepted = (DataContractBase)source;
						Contract targetAccepted = (Contract)target;
						ElementLink result = new DataContractBaseCanBeContainedOnContracts(sourceAccepted, targetAccepted);
						if(DomainClassInfo.HasNameProperty(result))
						{
							DomainClassInfo.SetUniqueName(result);
						}

						using(Transaction transaction = targetAccepted.Store.TransactionManager.BeginTransaction())
						{
							ModelElementReference dataElement = target.Store.ElementFactory.CreateElement(ModelElementReference.DomainClassId) as ModelElementReference;
							dataElement.ModelElementGuid = result.Id;
							dataElement.Type = sourceAccepted.Name;

                            LinkedElementCollection<DataMember> members = ((DataContract)target).DataMembers;

                            dataElement.Name = GetDataElementName(sourceAccepted.Name, targetAccepted.Name, members);
                            members.Add(dataElement);

							transaction.Commit();
						}
						return result;
					}
				}
			}
			
			Debug.Fail("Having agreed that the connection can be accepted we should never fail to make one.");
			throw new InvalidOperationException();
		}