public void OnInputDataChangedIsCalledTwiceWhenChangingLinkTo()
{
//this is unwanted behaviour since we only need one notification actually
//but i see no simple way of detecting unlink/link without introducing extra complexity
//now is chosen to see the change as two separate changes.
//setup a sourceitem connected to a model
var sourceItem = new DataItem
{
Value = new Parameter <DateTime>()
};
var model = new SimplerModel();
model.DataItems.First(di => di.ValueType == typeof(Parameter <DateTime>)).LinkTo(sourceItem);
//reset call count
model.OnInputDataChangedCallCount = 0;
//link to other item
var otherItem = new DataItem();
model.DataItems.First(di => di.ValueType == typeof(Parameter <DateTime>)).LinkTo(otherItem);
Assert.AreEqual(2, model.OnInputDataChangedCallCount);
}
public void CheckDefaultDataItemRoles()
{
var model = new SimplerModel();
Assert.AreEqual(3, model.DataItems.Where(di => di.Role == DataItemRole.Input).Count());
Assert.AreEqual(1, model.DataItems.Where(di => di.Role == DataItemRole.None).Count());
}
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 void OnInputDataChangedIsCalledOnceParameterChanges()
{
//should get two property changes. one for parameter.Value and one for ProgressStart
var model = new SimplerModel();
Assert.AreEqual(0, model.OnInputDataChangedCallCount);
((Parameter <DateTime>)model.DataItems.First(di => di.ValueType == typeof(Parameter <DateTime>)).Value).Value = DateTime.Now;
Assert.AreEqual(1, model.OnInputDataChangedCallCount);
}
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 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());
}
private static Project Create17ItemsProjectTree()
{
// RootFolder
// |-DataItem1
// |-DataItem1Value
// |-Folder 1
// |-DataItemSet1
// |-DataItem2
// |-string
// |-Model
// |-DataItem3
// |-StartTime
// |-StartTimeValue
// |-StopTime
// |-StopTimeValue
// |-CurrentTime
// |-CurrentTimeValue
// |-TimeStep
// |-TimeStepValue
Project p = new Project();
var folder = new Folder("folder1");
p.RootFolder.Items.Add(new DataItem {
Value = "dataItem1Value"
});
var set = new DataItemSet("dataItemSet1");
var dataItem2 = new DataItem {
Name = "DataItem2"
};
dataItem2.Value = "string";
set.DataItems.Add(dataItem2);
//TODO : replace simplermodel with a mock/stubbed object
SimplerModel model = new SimplerModel();
model.DataItems.Add(new DataItem()
{
Name = "DataItem3"
});
folder.Items.Add(set);
p.RootFolder.Add(folder);
p.RootFolder.Add(model);
return(p);
}
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", Tag = "SI", Value = new object(), Role = DataItemRole.Input
};
IDataItem sourceOutput = new DataItem {
Name = "SO", Tag = "SO", Value = new object(), Role = DataItemRole.Output
};
IDataItem targetInput = new DataItem {
Name = "TI", Tag = "TI", Value = new object(), Role = DataItemRole.Input
};
IDataItem targetOutput = new DataItem {
Name = "TO", Tag = "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 OnInputDataChangedIsCalledOnceWhenLinkingInputDataItems()
{
//setup a sourceitem and a model
var sourceItem = new DataItem
{
Value = new Parameter <DateTime>()
};
var model = new SimplerModel();
//connect the model to the sourceitem
model.DataItems.First(di => di.ValueType == typeof(Parameter <DateTime>)).LinkTo(sourceItem);
Assert.AreEqual(1, model.OnInputDataChangedCallCount);
}
public void GetAllItemsRecursive()
{
SimplerModel model = new SimplerModel();
var dataItem = new DataItem();
model.DataItems.Add(dataItem);
var items = model.GetAllItemsRecursive().ToArray();
Assert.AreEqual(new object[]
{
model, model.DataItems[0], model.DataItems[1], model.DataItems[2], model.DataItems[3],
dataItem, model.DataItems[0].Value, model.DataItems[1].Value, model.DataItems[2].Value,
model.DataItems[3].Value
},
model.GetAllItemsRecursive().ToArray());
}
public void OnInputDataChangedIsCalledOnceWhenLinkingInputDataItems()
{
//setup a sourceitem and a model
var sourceItem = new DataItem
{
Value = new Parameter <int>()
};
var model = new SimplerModel();
//connect the model to the sourceitem
model.DataItems[0].LinkTo(sourceItem);
Assert.AreEqual(1, model.OnInputDataChangedCallCount);
}
public void OnInputDataChangedIsCalledOnceWhenUnLinkingInputDataItems()
{
//setup a sourceitem connected to a model
var sourceItem = new DataItem
{
Value = new Parameter <DateTime>()
};
var model = new SimplerModel();
model.DataItems.First(di => di.ValueType == typeof(Parameter <DateTime>)).LinkTo(sourceItem);
//reset call counts
model.OnInputDataChangedCallCount = 0;
//unlink
model.DataItems.First(di => di.ValueType == typeof(Parameter <DateTime>)).Unlink();
Assert.AreEqual(1, model.OnInputDataChangedCallCount);
}
public void OnInputDataChangedIsCalledWhenTheValueOfADataItemChanges()
{
var parameter = new Parameter <DateTime>();
var sourceItem = new DataItem
{
Value = parameter
};
var model = new SimplerModel();
model.DataItems.First(di => di.ValueType == typeof(Parameter <DateTime>)).LinkTo(sourceItem);
//reset call count
model.OnInputDataChangedCallCount = 0;
//action..set a value
parameter.Value = new DateTime(2010);
Assert.AreEqual(1, model.OnInputDataChangedCallCount);
}
public void OnInputDataChangedIsCalledWhenTheValueOfADataItemChanges()
{
var parameter = new Parameter <int>();
var sourceItem = new DataItem
{
Value = parameter
};
var model = new SimplerModel();
model.DataItems[0].LinkTo(sourceItem);
//reset call count
model.OnInputDataChangedCallCount = 0;
//action..set a value
parameter.Value = 2;
Assert.AreEqual(1, model.OnInputDataChangedCallCount);
}
