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 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 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);
}