private TypeBindingInformationState NewTypeBindingInformation( CompositeValidationResultMutable vResult, CollectionsFactory collectionsFactory, CompositeModel compositeModel, AbstractInjectableModel injModel, Type nInfo, Type type, Type declaringType, IDictionary <Type, TypeBindingInformationState> privateComposites ) { TypeBindingInformationState state = new TypeBindingInformationState(collectionsFactory); state.NativeInfo = nInfo.GetGenericDefinitionIfContainsGenericParameters(); ListProxy <ListProxy <AbstractGenericTypeBinding> > bindings = collectionsFactory.NewListProxy <ListProxy <AbstractGenericTypeBinding> >(); Boolean allBindingsOK = this.NewGenericTypeBinding(collectionsFactory, compositeModel, type, declaringType, bindings, privateComposites); if (allBindingsOK) { state.Bindings.AddRange(bindings.CQ); } else if (vResult != null) { vResult.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("Failed to deduce generic bindings for " + (injModel == null ? (Object)type : injModel) + ".", compositeModel, injModel as AbstractMemberInfoModel <Object>)); } return(allBindingsOK ? state : null); }
public void CloneModel() { var compositeModel = new CompositeModel(); var containedModel = mocks.StrictMock <IModel>(); var modelClone = mocks.StrictMock <IModel>(); using (mocks.Record()) { Expect.Call(containedModel.Owner = compositeModel); Expect.Call(containedModel.DataItems).Return(new EventedList <IDataItem>()).Repeat.Any(); Expect.Call(containedModel.GetDirectChildren()).Return(new EventedList <object>()).Repeat.Any(); Expect.Call(containedModel.DeepClone()).Return(modelClone); containedModel.StatusChanged += null; LastCall.IgnoreArguments(); //containedModel.StatusChanged -= null; //LastCall.IgnoreArguments(); Expect.Call(modelClone.Owner = null).IgnoreArguments(); modelClone.StatusChanged += null; LastCall.IgnoreArguments(); Expect.Call(modelClone.DataItems).Return(new EventedList <IDataItem>()).Repeat.Any(); Expect.Call(modelClone.GetDirectChildren()).Return(new EventedList <object>()).Repeat.Any(); } CompositeModel clonedModel; using (mocks.Playback()) { compositeModel.Models.Add(containedModel); clonedModel = (CompositeModel)compositeModel.DeepClone(); } Assert.AreEqual(compositeModel.Models.Count, clonedModel.Models.Count); }
public void TestSequenceLinkFirstSourceThenTarget() { string result = ""; SimplerModel sourceModel = new SimplerModel {Name = "source"}; sourceModel.Executing += (s, e) => result += ((SimplerModel)s).Name; SimplerModel targetModel = new SimplerModel { Name = "target" }; targetModel.Executing += (s, e) => result += ((SimplerModel)s).Name; IDataItem sourceInput = new DataItem { Name = "SI", Value = new object(), Role = DataItemRole.Input }; IDataItem sourceOutput = new DataItem { Name = "SO", Value = new object(), Role = DataItemRole.Output }; IDataItem targetInput = new DataItem { Name = "TI", Value = new object(), Role = DataItemRole.Input }; IDataItem targetOutput = new DataItem { Name = "TO", Value = new object(), Role = DataItemRole.Output }; sourceModel.DataItems.Add(sourceInput); sourceModel.DataItems.Add(sourceOutput); targetModel.DataItems.Add(targetInput); targetModel.DataItems.Add(targetOutput); var compositeModel = new CompositeModel { Name = "composite model", Models = { sourceModel, targetModel } }; targetInput.LinkTo(sourceOutput); compositeModel.Initialize(); compositeModel.Execute(); Assert.AreEqual("sourcetarget", result); }
public void CloneModel() { var compositeModel = new CompositeModel(); var containedModel = mocks.StrictMock <IModel>(); var modelClone = mocks.StrictMock <IModel>(); using (mocks.Record()) { Expect.Call(containedModel.Owner = compositeModel); Expect.Call(containedModel.DataItems).Return(new EventedList <IDataItem>()).Repeat.Any(); Expect.Call(containedModel.GetAllItemsRecursive()).Return(new EventedList <object>()).Repeat.Any(); Expect.Call(containedModel.DeepClone()).Return(modelClone); Expect.Call(modelClone.Owner = null).IgnoreArguments(); Expect.Call(modelClone.DataItems).Return(new EventedList <IDataItem>()).Repeat.Any(); Expect.Call(modelClone.GetAllItemsRecursive()).Return(new EventedList <object>()).Repeat.Any(); } compositeModel.Models.Add(containedModel); CompositeModel clonedModel; using (mocks.Playback()) { clonedModel = (CompositeModel)compositeModel.DeepClone(); } Assert.AreEqual(compositeModel.Models.Count, clonedModel.Models.Count); }
protected virtual void EmitPlainCompositeHashCode( CompositeCodeGenerationInfo codeGenerationInfo, CompositeModel compositeModel, CompositeTypeModel typeModel, CompositeTypeGenerationInfo publicCompositeGenInfo, CompositeTypeGenerationInfo thisGenInfo, CompositeEmittingInfo emittingInfo, IEnumerable <FragmentTypeGenerationInfo> fragmentGenerationInfos ) { this.EmitCallNonCompositeMethod( codeGenerationInfo, compositeModel, typeModel, publicCompositeGenInfo, thisGenInfo, emittingInfo, fragmentGenerationInfos, HASH_CODE_METHOD, null, null, genInfos => genInfos.FirstOrDefault(genInfo => { var result = thisGenInfo.Parents.Keys.Where(t => !thisGenInfo.Builder.Equals(t)).OnlyBottomTypes().Where(t => !OBJECT_TYPE.Equals(t)).Any(p => genInfo.Parents.ContainsKey(p.GenericDefinitionIfGArgsHaveGenericParams())) || genInfo.DirectBaseFromModel.GetFullInheritanceChain().Any(t => compositeModel.ApplicationModel.GenericFragmentBaseType.NewWrapperAsType(this.ctx).Equals(t)); if (result) { var m = TypeGenerationUtils.FindMethodImplicitlyImplementingMethod(genInfo.DirectBaseFromModel, HASH_CODE_METHOD); result = !HASH_CODE_METHOD.Equals(m); } return(result); }) ); }
public TestBox(CompositeModel cm) : base(cm) { this.model.addCollisionBox(new Vector3(10f, 5f, 10f), Vector3.Up * 2.5f, 0); this.model.addBoundingCylinder(5f, 8f, Vector3.Up * 2.5f); this.targetHeight = this.model.Position.Y; }
public void TestProgressIndication() { string result = ""; var model1 = new SimplerModel { Name = "source" }; model1.Executing += (s, e) => result += ((SimplerModel)s).Name; var model2 = new SimplerModel { Name = "target" }; model2.Executing += (s, e) => result += ((SimplerModel)s).Name; var compositeModel = new CompositeModel { Name = "composite model", Models = { model1, model2 } }; var progressList = new List <string>(); compositeModel.ProgressChanged += delegate { progressList.Add(compositeModel.GetProgressText()); }; compositeModel.Initialize(); compositeModel.Execute(); Assert.AreEqual("50.00 %", progressList[0]); Assert.AreEqual("100.00 %", progressList[1]); }
public CompositeTypeGenerationInfo GetPublicComposite(CompositeModel model, Assembly assembly) { CompositeTypeGenerationInfo result; this._publicCompositeGenerationInfo.TryGetValue(Tuple.Create(assembly, model), out result); return(result); }
/// <summary> /// Gets enumerable of all composite types, including private composite types, of given <see cref="CompositeModel"/>. /// </summary> /// <param name="model">The <see cref="CompositeModel"/>.</param> /// <returns>Enumerable of all composite types, including private composites types, of given <paramref name="model"/>.</returns> /// <exception cref="NullReferenceException">If <paramref name="model"/> is <c>null</c>.</exception> public static IEnumerable <Type> GetAllCompositeTypes(this CompositeModel model) { return(model.Methods .Select(cMethod => cMethod.NativeInfo.DeclaringType) .Concat(model.PublicTypes) .Concat(model.GetAllInjectableModelsWithInjectionScope <Qi4CS.Core.API.Model.ThisAttribute>().Select(i => i.TargetType)) .GetBottomTypes()); }
/// <summary> /// Gets enumerable of all <see cref="AbstractInjectableModel"/>s of given <see cref="CompositeModel"/>. /// </summary> /// <param name="model">The <see cref="CompositeModel"/>.</param> /// <returns>Enumerable of all <see cref="AbstractInjectableModel"/>s of given <paramref name="model"/>.</returns> /// <exception cref="NullReferenceException">If <paramref name="model"/> is <c>null</c>.</exception> public static IEnumerable <AbstractInjectableModel> GetAllInjectableModels(this CompositeModel model) { return(model.Fields .Cast <AbstractInjectableModel>() .Concat(model.Constructors.SelectMany(ctor => ctor.Parameters)) .Concat(model.Methods.SelectMany(method => method.Parameters)) .Concat(model.SpecialMethods.SelectMany(method => method.Parameters))); }
public ModuleModel FindModuleModel(CompositeModel compositeModel) { return(this._allLayers.MQ .SelectMany(layer => layer.InternalModuleModels) .Where(module => module.IQ.CompositeModelsInThisContainer.Contains(compositeModel)) .Select(module => module.IQ) .FirstOrDefault()); }
public virtual CompositeBuilder CreateBuilder(StructureServiceProviderSPI structureServiceProvider, Type[] compositeTypes) { ThrowIfGenericParams(compositeTypes); CompositeModel model = structureServiceProvider.Structure.ModelInfoContainer.GetCompositeModelInfo(this.ModelScopeSupport.AssemblyScopeSupport.ModelType, compositeTypes).Model; UsesContainerMutable uses = UsesContainerMutableImpl.CreateWithParent(model.UsesContainer); return(new CompositeBuilderImpl(compositeTypes, uses, (CompositeInstanceImpl)this.CreateInstance(structureServiceProvider.Structure, model, compositeTypes, uses.Query))); }
protected override IEnumerable <ServiceCompositeModel> FindSuitableModels(CompositeModel compositeModel, AbstractInjectableModel model, Attribute scope, Type targetType, Type serviceType) { return(((ModelContainer)compositeModel.ApplicationModel).CompositeModelsInThisContainer.Where(cModel => cModel.PublicTypes.Any(pType => serviceType.IsAssignableFrom_IgnoreGenericArgumentsForGenericTypes(pType))) .Cast <ServiceCompositeModel>()); //return new ValidationResult( // ( (ModelContainer) compositeModel.ApplicationModel ).CompositeModelsInThisContainer.Any( cModel => cModel.PublicTypes.Any( pType => TypeUtil.IsAssignableFrom( serviceType, pType ) ) ), // "The service of type " + serviceType + " is not added to application." // ); }
protected override void PostValidateModel(CompositeModel compositeModel, CompositeValidationResult validationResult) { ServiceCompositeModel sModel = (ServiceCompositeModel)compositeModel; if (sModel.PublicTypes.Any(pType => pType.ContainsGenericParameters())) { validationResult.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("All the generic arguments of service composite's all public types must be closed.", compositeModel)); } }
public IActionResult ReadyFileDetails([FromQuery] String cName) { ViewData["cFileName"] = cName; CompositeModel composeFileDetails = ComposerNew.GetSingleCompositeDetail(cName, false); //String basePath = Path.Combine(Directory.GetCurrentDirectory(), "data/templates/" + cName); //String contents = System.IO.File.ReadAllText(basePath); return(View(composeFileDetails)); }
public SimulationModel() { Regions = new CompositeLookupModel <uint, RegionModel>(); Connections = new CompositeModel <ConnectionModel>(); Observers = new Dictionary <ObserverDefinition, ObserverData>(); AddChild(Regions); AddChild(Connections); }
/// <summary> /// Gets enumerable of all fragment types of given <see cref="CompositeModel"/>. /// </summary> /// <param name="model">The <see cref="CompositeModel"/>.</param> /// <returns>Enumerable of all fragment types of given <paramref name="model"/>.</returns> /// <exception cref="NullReferenceException">If <paramref name="model"/> is <c>null</c>.</exception> public static IEnumerable <Type> GetAllFragmentTypes(this CompositeModel model) { return(model.Methods .SelectMany(cMethod => cMethod.GetAllMethodModels().OfType <AbstractMethodModelWithFragment>()) .Concat(model.SpecialMethods) .GroupBy(mModel => mModel.GetType()) .SelectMany(grp => grp.Select(mModel => mModel.FragmentType).GetBottomTypes()) .Distinct()); }
/// <summary> /// Gets enumerable of all <see cref="ConstraintModel"/>s of given <see cref="CompositeModel"/>. /// </summary> /// <param name="model">The <see cref="CompositeModel"/>.</param> /// <returns>Enumerable of all <see cref="ConstraintModel"/>s of given <paramref name="model"/>.</returns> /// <exception cref="NullReferenceException">If <paramref name="model"/> is <c>null</c>.</exception> public static IEnumerable <ConstraintModel> GetAllConstraints(this CompositeModel model) { return(model.Methods .SelectMany(method => method.Parameters.SelectMany(param => param.Constraints)) .Concat(model.Constructors.SelectMany(ctor => ctor.Parameters.SelectMany(param => param.Constraints))) .Concat(model.SpecialMethods.SelectMany(method => method.Parameters.SelectMany(param => param.Constraints))) .Concat(model.Methods.SelectMany(method => method.Result.Constraints)) .Concat(model.SpecialMethods.SelectMany(method => method.ResultModel.Constraints))); }
public PublicCompositeTypeGenerationResult LoadTypes(CompositeModel compositeModel, CompositeTypeModel tModel, EventHandler <AssemblyLoadingArgs> loadingEvt, IDictionary <Assembly, Assembly> assDic) { return(new PublicCompositeTypeGenerationResultImpl( compositeModel, tModel, loadingEvt, assDic, this._codeGenerationInfo )); }
protected static Type GetGeneratedPublicType(Type type, CompositeModel model, CompositeCodeGenerationInfo codeGenerationInfo, EventHandler <AssemblyLoadingArgs> loadingEvt, IDictionary <Assembly, Assembly> assDic) { return(assDic.GetOrAdd_NotThreadSafe( type.GetAssembly(), a => ReflectionHelper.QI4CS_ASSEMBLY.Equals(a) ? assDic[model.MainCodeGenerationType.GetAssembly()] : DoLoadGeneratedAssembly(a, model.ApplicationModel, loadingEvt) ).GetType( codeGenerationInfo.PublicCompositePrefix + model.CompositeModelID, true )); }
private Boolean ProcessGenericTypeBindingFromPublicComposite( CompositeModel cModel, CollectionsFactory cf, Tuple <Type, Type> pcType, Type type, out ListProxy <AbstractGenericTypeBinding> result ) { var retyrn = type.IsGenericParameter; if (retyrn) { result = cf.NewListProxy(new List <AbstractGenericTypeBinding>()); } else { var array = type.GetGenericArguments().Select(t => { AbstractGenericTypeBinding gtb = null; var gIdx = Array.IndexOf(pcType.Item1.GetGenericArguments(), t); var retyrn2 = !t.IsGenericParameter || gIdx != -1; if (retyrn2) { if (t.IsGenericParameter) { var state = new IndirectGenericTypeBindingState(); state.GenericDefinition = cModel.PublicTypes.First(pt => pt.GetAllParentTypes().Select(ptt => ptt.GetGenericDefinitionIfGenericType()).Any(ptt => ptt.Equals(pcType.Item2.GetGenericDefinitionIfGenericType()))); state.GenericIndex = gIdx; gtb = new IndirectGenericTypeBindingImpl(state); } else { var state = new DirectGenericTypeBindingState(); state.Type = t; retyrn2 = this.ProcessGenericTypeBindingFromPublicComposite(cModel, cf, pcType, t, out state._innerBindings); gtb = new DirectGenericTypeBindingImpl(state); } } else { } return(Tuple.Create(retyrn2, gtb)); }).ToArray(); retyrn = array.Count(tuple => tuple.Item1) == type.GetGenericArguments().Length; if (retyrn) { result = cf.NewListProxy(array.Select(a => a.Item2).ToList()); } else { result = null; } } return(retyrn); }
protected virtual void ValidateField(CompositeValidationResult result, CompositeModel compositeModel, FieldModel fieldModel) { if (fieldModel == null) { result.InternalValidationErrors.Add(ValidationErrorFactory.NewInternalError("Field model may not be null.", compositeModel)); } else { this.ValidateInjectableModel(result, compositeModel, fieldModel); } }
//[Route("{cName}")] public IActionResult TemplateDetails([FromQuery] String cName) { ViewData["cFileName"] = cName; CompositeModel composeFileDetails = ComposerNew.GetSingleCompositeDetail(cName, true); String basePath = Path.Combine(Program.ComposeTemplateDir, cName); String contents = System.IO.File.ReadAllText(basePath); String[] parameters = ComposerNew.ExtractParameters(contents); ViewData["params"] = parameters; return(View(composeFileDetails)); }
protected override void EmitPublicCompositeHashCode( CompositeCodeGenerationInfo codeGenerationInfo, CompositeModel compositeModel, CompositeTypeModel typeModel, CompositeTypeGenerationInfo publicCompositeGenInfo, CompositeTypeGenerationInfo thisGenInfo, CompositeEmittingInfo emittingInfo, IEnumerable <FragmentTypeGenerationInfo> fragmentGenerationInfos ) { this.EmitPlainCompositeHashCode(codeGenerationInfo, compositeModel, typeModel, publicCompositeGenInfo, thisGenInfo, emittingInfo, fragmentGenerationInfos); }
public void CompositeModelUnSubscribesFromChildModelsWhenRemoved() { var compositeModel = new CompositeModel(); var childModel = new TestModel(); compositeModel.Models.Add(childModel); compositeModel.Models.Remove(childModel); compositeModel.StatusChanged += (s, e) => Assert.Fail("Should have unsubscribed!"); childModel.Status = ActivityStatus.Initializing; }
public void GetItemsRecursiveShouldReturnModelsContainedByCompositeMOdel() { var model = new CompositeModel(); var model1 = new SimplerModel(); model.Models.Add(model1); Project project = new Project(); project.RootFolder.Add(model); Assert.IsTrue(project.GetAllItemsRecursive().Contains(model1)); }
public void CompositeModelUpdatesChildren() { var modelMock = new Mock <IModel>(); IModel model = modelMock.Object; var compositeModel = new CompositeModel <IModel>(); compositeModel.AddChild(model); compositeModel.Update(0); modelMock.Verify(m => m.Update(0)); }
protected static Type GetParticipantType(Type type, CompositeModel model, CompositeCodeGenerationInfo codeGenerationInfo, EventHandler <AssemblyLoadingArgs> loadingEvt, IDictionary <Assembly, Assembly> assDic, String prefix, Boolean useBaseType = false) { return(GetGeneratedPublicType(type, model, codeGenerationInfo, loadingEvt, assDic) #if WINDOWS_PHONE_APP .GetTypeInfo().DeclaredNestedTypes.Select(t => t.AsType()) #else .GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic) #endif .FirstOrDefault(tt => tt.Name.StartsWith(prefix) && (useBaseType ? tt.GetBaseType().GetGenericDefinitionIfContainsGenericParameters().Equals(type) : tt.GetAllParentTypes().Any(ttt => ttt.GetGenericDefinitionIfContainsGenericParameters().Equals(type))) //&& !TypeUtil.TypesOf( tt ).Except( new Type[] { tt, type } ).Any( ttt => TypeUtil.IsAssignableFrom( TypeUtil.GenericDefinitionIfContainsGenericParams( type ), ttt ) ) )); }
ToCompositeObjectCollection <T, T1, T2, T3, T4> (IEnumerable <dynamic> queryResult) { JArray json = JArray.FromObject(queryResult); var result = new List <CompositeModel <T, T1, T2, T3, T4> >(); foreach (JObject obj in json) { var converted = UnderscoreToPascalProps(obj); var compositeObj = new CompositeModel <T, T1, T2, T3, T4>(converted); result.Add(compositeObj); } return(result); }
// GET: /<controller>/ public IActionResult Chart() { //var assetModel = new AssetModel(); //var datesModel = new OptionModel(); //var assetDbRepo = new DatabaseReadonlyAssetRepository(); //var datesDbRepo = new DatabaseReadonlyExpDatesRepository(); //var dates = datesDbRepo.GetDates().ToList(); //assetModel.AssetList = assetDbRepo.GetAssets().ToList(); //datesModel.ExpDatesList = JsonConvert.SerializeObject(dates); var compositeModel = new CompositeModel(); return(View(compositeModel)); }
public ModelInfoImpl( CompositeModel model, PublicCompositeTypeGenerationResult types, CollectionsFactory collectionsFactory ) { this._model = model; this._types = types; this._compositeMethodAttributeHolders = collectionsFactory.NewListProxy( model.Methods .Select(cMethod => (AttributeHolder) new AttributeHolderImpl(collectionsFactory, cMethod.GetAllMethodModels().Select(mModel => mModel.NativeInfo))) .ToList() ).CQ; }
public void GetAllItemsRecursiveShouldReturnModels() { var compositeModel = new CompositeModel(); var model = new SimplerModel(); compositeModel.Models.Add(model); IEnumerable <object> enumerable = compositeModel.GetAllItemsRecursive(); Assert.IsTrue(enumerable.Contains(model)); Assert.AreEqual( 1 + compositeModel.DataItems.Count * 2 + model.GetAllItemsRecursive().Count(), enumerable.Count()); }
const float TOWERHEIGHT = 485.75f; //166.5f; #endregion Fields #region Constructors public Tower(CompositeModel cm) : base(cm) { this.model.addBoundingCylinder(TOWERHEIGHT + 50, 175, Vector3.Up *(25 + TOWERHEIGHT/2) ); this.model.addCollisionCylinder(TOWERHEIGHT - 20, 110f, Vector3.Up * (TOWERHEIGHT - 20)/2f); this.model.addCollisionCylinder(20, 140, Vector3.Up * (TOWERHEIGHT - 10f)); float thetaOffset = -0.0125f; float dist = 131f; //this.model.addCollisionBox(new Vector3(17, 28, 52.5f), new Vector3(dist * (float)Math.Cos(thetaOffset), TOWERHEIGHT, dist* (float)Math.Sin(thetaOffset)), thetaOffset); for (int i = 0; i <8; i++) { //higher sections this.model.addCollisionBox(new Vector3(17, 28, 52.5f), new Vector3(dist * (float)Math.Cos(thetaOffset + (float)Math.PI / 4f * i), TOWERHEIGHT, dist * (float)Math.Sin(thetaOffset + (float)Math.PI / 4f * i)), thetaOffset - (float)Math.PI / 4 * i + (float)Math.PI); //lower sections this.model.addCollisionBox(new Vector3(17, 14, 52.5f), new Vector3(dist * (float)Math.Cos(thetaOffset + (float)Math.PI / 4f * i + (float)Math.PI / 8), TOWERHEIGHT, dist * (float)Math.Sin(thetaOffset + (float)Math.PI / 4f * i + (float)Math.PI / 8)), thetaOffset - (float)Math.PI / 4 * i + (float)Math.PI - (float)Math.PI / 8); } }
public void GetAllItemsRecursiveShouldReturnModels() { var compositeModel = new CompositeModel(); var model = new SimplerModel(); compositeModel.Models.Add(model); IEnumerable<object> enumerable = compositeModel.GetAllItemsRecursive(); Assert.IsTrue(enumerable.Contains(model)); Assert.AreEqual( 1 + compositeModel.DataItems.Count*2 +model.GetAllItemsRecursive().Count(), enumerable.Count()); }
public RotTestBox(CompositeModel cm) : base(cm) { this.model.addCollisionBox(new Vector3(10f,5f,10f), Vector3.Up * 2.5f, 0); }
public void CloneModel() { var compositeModel = new CompositeModel(); var containedModel = mocks.StrictMock<IModel>(); var modelClone = mocks.StrictMock<IModel>(); using (mocks.Record()) { Expect.Call(containedModel.Owner = compositeModel); Expect.Call(containedModel.DataItems).Return(new EventedList<IDataItem>()).Repeat.Any(); Expect.Call(containedModel.GetAllItemsRecursive()).Return(new EventedList<object>()).Repeat.Any(); Expect.Call(containedModel.DeepClone()).Return(modelClone); Expect.Call(modelClone.Owner = null).IgnoreArguments(); Expect.Call(modelClone.DataItems).Return(new EventedList<IDataItem>()).Repeat.Any(); Expect.Call(modelClone.GetAllItemsRecursive()).Return(new EventedList<object>()).Repeat.Any(); } compositeModel.Models.Add(containedModel); CompositeModel clonedModel; using (mocks.Playback()) { clonedModel = (CompositeModel) compositeModel.DeepClone(); } Assert.AreEqual(compositeModel.Models.Count, clonedModel.Models.Count); }
public void CloneShouldUpdateLinksWithinModel() { //Situation // CompositeModel // |-SourceModel // |-LinkedModel (->SourceModel) //Clone this composite model and expect the c-linkedmodel to be connected to the cloned-sourcemodel. var compositeModel = new CompositeModel(); IModel sourceModel = new TestModel("source"); IDataItem sourceDataItem = new DataItem(new Url(), "sourceItem"); sourceModel.DataItems.Add(sourceDataItem); compositeModel.Models.Add(sourceModel); IModel linkedModel = new TestModel("linked"); IDataItem linkedDataItem = new DataItem {Name = "linkedItem"}; linkedModel.DataItems.Add(linkedDataItem); compositeModel.Models.Add(linkedModel); linkedDataItem.LinkTo(sourceDataItem); var clonedModel = (CompositeModel) compositeModel.DeepClone(); IModel clonedSourceModel = clonedModel.Models.Where(m => m.Name == "source").First(); IModel clonedLinkedModel = clonedModel.Models.Where(m => m.Name == "linked").First(); IDataItem clonedLinkedItem = clonedLinkedModel.DataItems.Where(d => d.Name == "linkedItem").First(); IDataItem clonedSourceItem = clonedSourceModel.DataItems.Where(d => d.Name == "sourceItem").First(); //the cloned sourceitem should not be the the sourcedataitem. Assert.AreNotEqual(clonedSourceItem.Value, sourceDataItem.Value); Assert.IsTrue(clonedLinkedItem.IsLinked); Assert.AreEqual(clonedSourceItem, clonedLinkedItem.LinkedTo); }