public void IDataContainer_ShouldRaisePropertyChanged()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("C", 3)
.Build();
var listener = new PropertyChangedListener(A);
A["A"] = 55;
Assert.Equal("A", listener.LastChangedProperty);
Assert.Single(listener.PropertiesChanged);
A["B"] = 23;
Assert.Equal("B", listener.LastChangedProperty);
Assert.Equal(2, listener.PropertiesChanged.Count);
A["C"] = 29;
Assert.Equal("C", listener.LastChangedProperty);
Assert.Equal(3, listener.PropertiesChanged.Count);
Assert.Contains("A", listener.PropertiesChanged);
Assert.Contains("B", listener.PropertiesChanged);
Assert.Contains("C", listener.PropertiesChanged);
}
public void IDataContainer_ShouldRaisePropertyChangedForNestedContainers()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("C", 3)
.DataContainer("AA", b => b
.Data("A1", 23)
.Data("A2", 24)
.DataContainer("AAA", b => b
.Data("AA1", 3)))
.Build();
var listener = new PropertyChangedListener(A);
A["A"] = 55;
Assert.Equal("A", listener.LastChangedProperty);
Assert.Single(listener.PropertiesChanged);
IDataContainer AA = (IDataContainer)A["AA"];
AA["A2"] = 42;
Assert.Equal("AA.A2", listener.LastChangedProperty);
Assert.Equal(2, listener.PropertiesChanged.Count);
IDataContainer AAA = (IDataContainer)AA["AAA"];
AAA["AA1"] = 5;
Assert.Equal("AA.AAA.AA1", listener.LastChangedProperty);
Assert.Equal(3, listener.PropertiesChanged.Count);
}
public void IDataContainer_InplaceIntersect_Works()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("C", 3)
.DataContainer("AA", b => b
.Data("A1", 11)
.Data("A2", 12))
.Data("D", 4)
.Build();
IDataContainer B = DataContainerBuilder.Create("B")
.Data("A", 1)
.Data("B", 2)
.Data("C", 3)
.Data("X", 4)
.Data("D", 2)
.Data("Z", 3)
.Build();
int commonCount = A.GetAllKeys().Intersect(B.GetAllKeys()).Count();
A.InplaceIntersect(B);
Assert.Equal(commonCount, A.GetAllKeys().Count());
}
public void DataObjectFactory_RegisterDataObject_Works()
{
DataObjectFactory.RegisterDataObject <Utils.PersonDataObject>();
IDataContainer dc = DataContainerBuilder.Create()
.Data("person", new Utils.Person {
FirstName = "John", LastName = "Doe"
})
.Build();
string xml = XmlHelper.SerializeToString(dc);
IDataContainer dcNew = XmlHelper.DeserializeFromString <System.Configuration.DataContainer>(xml);
Assert.True(dcNew.ContainsData("person"));
DataObject dobj = dcNew.Find("person");
Assert.Equal("prsn", dobj.Type);
Utils.Person p = dobj.GetValue() as Utils.Person;
Assert.Equal("John", p.FirstName);
Assert.Equal("Doe", p.LastName);
}
public void IDataContainer_Intersect_UsesValuesFromFirstForSameProperty()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Build();
IDataContainer B = DataContainerBuilder.Create("B")
.Data("A", 2)
.Data("B", 1)
.Build();
IDataContainer AintersectB = A.Intersect(B);
IDataContainer BintersectA = B.Intersect(A);
int AA = (int)A["A"];
int AB = (int)A["B"];
int BA = (int)B["A"];
int BB = (int)B["B"];
int AUBA = (int)AintersectB["A"];
int AUBB = (int)AintersectB["B"];
int BUAA = (int)BintersectA["A"];
int BUAB = (int)BintersectA["B"];
Assert.Equal(AA, AUBA);
Assert.Equal(AB, AUBB);
Assert.Equal(BA, BUAA);
Assert.Equal(BB, BUAB);
}
public void SnapShot_GetAllValuesMultiLevelData()
{
IDataContainer A = (DataContainerBase)DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("C", 3)
.DataContainer("AB", b => b
.Data("AB1", 1)
.Data("AB2", 2))
.Build();
SnapShot snapShot = A.GetSnapShot();
Assert.Equal(5, snapShot.Count());
Assert.Contains("A", snapShot.Keys);
Assert.Contains("B", snapShot.Keys);
Assert.Contains("C", snapShot.Keys);
Assert.Contains("AB.AB1", snapShot.Keys);
Assert.Contains("AB.AB2", snapShot.Keys);
Assert.Equal(A["A"], snapShot["A"].Value);
Assert.Equal(A["B"], snapShot["B"].Value);
Assert.Equal(A["C"], snapShot["C"].Value);
Assert.Equal(A["AB.AB1"], snapShot["AB.AB1"].Value);
Assert.Equal(A["AB.AB2"], snapShot["AB.AB2"].Value);
}
public void SnapShot_Difference_OnlyHasValuesWhichAreDifferent()
{
IDataContainer A = (DataContainerBase)DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("C", 3)
.DataContainer("AB", b => b
.Data("AB1", 1)
.Data("AB2", 2))
.Build();
IDataContainer B = (DataContainerBase)DataContainerBuilder.Create("B")
.Data("A", 1)
.Data("B", 22)
.Data("C", 3)
.DataContainer("AB", b => b
.Data("AB1", 1)
.Data("AB2", 21))
.Build();
SnapShotDiff diff = A.GetSnapShot() - B.GetSnapShot();
Assert.Equal(2, diff.Count());
Assert.Contains("B", diff.Keys);
Assert.Contains("AB.AB2", diff.Keys);
Assert.Equal(A["B"], diff["B"].Left);
Assert.Equal(B["B"], diff["B"].Right);
Assert.Equal(A["AB.AB2"], diff["AB.AB2"].Left);
Assert.Equal(B["AB.AB2"], diff["AB.AB2"].Right);
}
public void IDataContainer_Intersect_MustWorkWithSingleLevelData()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("C", 3)
.Data("E", 5)
.Data("G", 7)
.Data("Z", 26)
.Build();
IDataContainer B = DataContainerBuilder.Create("A")
.Data("B", 2)
.Data("D", 4)
.Data("F", 6)
.Data("H", 8)
.Data("Z", 28)
.Build();
IDataContainer AintersectB = A.Intersect(B);
Assert.Equal(1, AintersectB.Count); // only 1 common
var keys = AintersectB.GetKeys().ToList();
keys.Sort();
Assert.Equal("Z", string.Join("", keys)); // all keys are present.
}
public void IDataContainer_Except_RemovesCommonProperties()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("C", 3)
.DataContainer("AA", b => b
.Data("A1", 11)
.Data("A2", 12))
.Data("D", 4)
.Build();
IDataContainer B = DataContainerBuilder.Create("B")
.Data("F", 1)
.Data("B", 2)
.Data("C", 3)
.Data("X", 4)
.Data("Y", 2)
.Data("Z", 3)
.Build();
IDataContainer AdifferenceB = A.Except(B);
IDataContainer BdifferenceA = B.Except(A);
Assert.Equal(3, AdifferenceB.Count); // remove B,C from A
Assert.Equal(4, BdifferenceA.Count); // remove B,C from B
}
public void IDataContainer_Union_MustWorkWithSingleLevelData()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("C", 3)
.Data("E", 5)
.Data("G", 7)
.Data("Z", 26)
.Build();
IDataContainer B = DataContainerBuilder.Create("A")
.Data("B", 2)
.Data("D", 4)
.Data("F", 6)
.Data("H", 8)
.Data("Z", 28)
.Build();
IDataContainer AunionB = A.Union(B);
Assert.Equal(9, AunionB.Count); // 4 + 4 + 1 (common)
var keys = AunionB.GetKeys().ToList();
keys.Sort();
Assert.Equal("ABCDEFGHZ", string.Join("", keys)); // all keys are present.
}
public void IDataContainer_Remove_RemovesCommonProperties()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("C", 3)
.DataContainer("AA", b => b
.Data("A1", 11)
.Data("A2", 12))
.Data("D", 4)
.Build();
var cloneA = A.Clone() as IDataContainer;
IDataContainer B = DataContainerBuilder.Create("B")
.Data("F", 1)
.Data("B", 2)
.Data("C", 3)
.Data("X", 4)
.Data("Y", 2)
.Data("Z", 3)
.Build();
var cloneB = B.Clone() as IDataContainer;
cloneA.Remove(B);
cloneB.Remove(A);
Assert.Equal(3, cloneA.Count); // remove B,C from A
Assert.Equal(4, cloneB.Count); // remove B,C from B
}
public void IDataContainer_IsIdenticalReturnsFalseForMultiLevelDataWithSameNumberOfKeys()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.DataContainer("AA", b => b
.Data("A1", 1)
.Data("A3", 3))
.Data("B", 2)
.Data("C", 3)
.DataContainer("CC", b => b
.Data("C1", 1)
.Data("C2", 2))
.Build();
IDataContainer B = DataContainerBuilder.Create("B")
.Data("A", 2)
.DataContainer("AA", b => b
.Data("A3", 3))
.Data("B", 3)
.Data("C", 4)
.DataContainer("CC", b => b
.Data("C1", 1)
.Data("C2", 2)
.Data("C3", 3))
.Build();
Assert.False(A.IsIdentical(B));
Assert.False(B.IsIdentical(A));
}
public void IDataContainer_IsIdenticalReturnsTrueForMultiLevelData()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.DataContainer("AA", b => b
.Data("A1", 1)
.Data("A2", 2)
.Data("A3", 3))
.Data("B", 2)
.Data("C", 3)
.DataContainer("CC", b => b
.Data("C1", 1)
.Data("C2", 2))
.Build();
IDataContainer B = DataContainerBuilder.Create("B")
.Data("A", 2)
.DataContainer("AA", b => b
.Data("A1", 1)
.Data("A2", 2)
.Data("A3", 3))
.Data("B", 3)
.Data("C", 4)
.DataContainer("CC", b => b
.Data("C1", 1)
.Data("C2", 2))
.Build();
Assert.True(A.IsIdentical(B));
Assert.True(B.IsIdentical(A));
}
public void IDataContainer_Union_UsesValuesFromFirstForSameProperty()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Build();
IDataContainer B = DataContainerBuilder.Create("B")
.Data("A", 2)
.Data("B", 1)
.Build();
IDataContainer AunionB = A.Union(B);
IDataContainer BunionA = B.Union(A);
int AA = (int)A["A"];
int AB = (int)A["B"];
int BA = (int)B["A"];
int BB = (int)B["B"];
int AUBA = (int)AunionB["A"];
int AUBB = (int)AunionB["B"];
int BUAA = (int)BunionA["A"];
int BUAB = (int)BunionA["B"];
Assert.Equal(AA, AUBA);
Assert.Equal(AB, AUBB);
Assert.Equal(BA, BUAA);
Assert.Equal(BB, BUAB);
}
public void DataContainerAutoSaver_WillNotUseFiltersIfUseFilterIsFalse()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("D", 3)
.Build();
var tester = new AutoSaveTester(A);
tester.AutoSaver.SaveDelay = 10;
tester.AutoSaver.UseFilters = false;
tester.AutoSaver.AddFilter("D");
Assert.False(tester.SavingStartedInvoked);
Assert.False(tester.SavingFinishedInvoked);
A["B"] = 5;
// wait timer
Thread.Sleep((int)tester.AutoSaver.SaveDelay + 20);
Assert.True(tester.SavingStartedInvoked);
Assert.True(tester.SavingFinishedInvoked);
}
[InlineData(typeof(UninitializedPOCO), 4)] // Should not create data for null properties, or should it ??
public void DataContainerBuilder_CreateObject_MustCreatesObjectWithCorrectCount(Type t, int count)
{
var obj = Activator.CreateInstance(t);
IDataContainer data = DataContainerBuilder.CreateObject("Untitiled", obj);
Assert.Equal(count, data.Count);
}
public void DataContainerAutoUpdater_ShouldAddNewValuesWithMultiLevelData()
{
string path = Path.GetTempFileName();
DataContainerBase A = (DataContainerBase)DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("D", 3)
.DataContainer("AB", b => b
.Data("AB1", 1))
.Build();
A.FilePath = path;
A.SaveAsXml(path);
var tester = new AutoUpateTester(A);
tester.AutoUpdater.PollingInterval = 10;
// allow adding
tester.AutoUpdater.CanAddItems = true;
Assert.False(tester.UpdateStartedInvoked);
Assert.False(tester.UpdateFinishedInvoked);
IDataContainer Updated = (DataContainerBase)DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("D", 3)
.DataContainer("AB", b => b
.Data("AB1", 1)
.Data("AB2", 2))
.Build();
Updated.SaveAsXml(path);
// wait timer
Thread.Sleep((int)tester.AutoUpdater.PollingInterval + 20);
Assert.True(tester.UpdateStartedInvoked);
Assert.True(tester.UpdateFinishedInvoked);
IDataContainer AB = (IDataContainer)A["AB"];
// 1 value added
Assert.Equal(2, AB.Count);
// check if value exist
Assert.True(AB.ContainsData("AB2"));
// check it has correct value
Assert.Equal(2, (int)AB["AB2"]);
File.Delete(path);
}
public void DataContainerBuilder_CreateObject_MustCreateObjectWithCorrectValue(Type t)
{
var obj = Activator.CreateInstance(t);
IDataContainer data = DataContainerBuilder.CreateObject("Untitiled", obj);
foreach (var item in data)
{
var expected = t.GetProperty(item.Name).GetValue(obj);
var actual = item.GetValue();
Assert.Equal(expected, actual);
}
}
public void IDataContainer_Clone_WorksForValueTypes()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", new Color(1, 1, 1))
.Build();
IDataContainer clone = (IDataContainer)A.Clone();
Assert.Equal(A.Count, clone.Count);
Assert.True(A.GetKeys().SequenceEqual(clone.GetKeys()));
Assert.Equal(A["A"], clone["A"]);
Assert.Equal(A["B"], clone["B"]);
}
public void IDataContainer_Intersect_MustWorkWithMultiLevelData()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.DataContainer("AA", b => b
.Data("A1", 11)
.Data("A2", 12)
.Data("A3", 13))
.Data("C", 3)
.DataContainer("CC", b => b
.Data("C1", 31)
.Data("C3", 33))
.DataContainer("BB", b => b
.Data("B1", 21)
.Data("B2", 22))
.Build();
IDataContainer B = DataContainerBuilder.Create("B")
.Data("A", 1)
.Data("B", 2)
.DataContainer("AA", b => b
.Data("A4", 14)
.Data("A5", 15)
.Data("A6", 16))
.Data("C", 3)
.DataContainer("CC", b => b
.Data("C2", 32))
.DataContainer("BB", b => b
.Data("B1", 23)
.Data("B2", 24)
.Data("B3", 25))
.Build();
IDataContainer AintersectB = A.Intersect(B);
Assert.Equal(6, AintersectB.Count); // both have same keys, 6
IDataContainer AA = (IDataContainer)AintersectB["AA"];
Assert.Equal(0, AA.Count); // nothing common
IDataContainer CC = (IDataContainer)AintersectB["CC"];
Assert.Equal(0, CC.Count); // nothing common
IDataContainer BB = (IDataContainer)AintersectB["BB"];
Assert.Equal(2, BB.Count); // 2 common, 1 only in B
}
public void IDataCointainer_Clone_WorksForReferenceTypes()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", new object())
.Data("B", new object())
.Build();
IDataContainer clone = (IDataContainer)A.Clone();
Assert.Equal(A.Count, clone.Count);
Assert.True(A.GetKeys().SequenceEqual(clone.GetKeys()));
Assert.NotSame(A["A"], clone["A"]);
Assert.NotSame(A["B"], clone["B"]);
}
public void DataContainerBase_CanAccessChildDataFromRoot()
{
DataContainerBase Root = (DataContainerBase)DataContainerBuilder.Create("Root")
.DataContainer("Child", b => b
.DataContainer("GrandChild", c => c
.Data("A", 1)
.Data("B", 2)))
.Build();
int a = Root.GetValue(new Key <int>("Child.GrandChild.A"));
int b = Root.GetValue(new Key <int>("Child.GrandChild.B"));
Assert.Equal(1, a);
Assert.Equal(2, b);
}
public void DataContainerBase_Morph_MustRecreatesSameObject(Type t)
{
var obj = Activator.CreateInstance(t);
DataContainerBase data = (DataContainerBase)DataContainerBuilder.CreateObject("Untitiled", obj);
var morphedData = data.Morph();
foreach (var prop in t.GetProperties())
{
var expected = prop.GetValue(obj);
var actualData = prop.GetValue(morphedData);
Assert.Equal(expected, actualData);
}
}
public void IDataContainer_IsIdenticalReturnsFalseForSingleLevelData()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Build();
IDataContainer B = DataContainerBuilder.Create("B")
.Data("A", 2)
.Data("B", 3)
.Data("C", 4)
.Build();
Assert.False(A.IsIdentical(B));
Assert.False(B.IsIdentical(A));
}
public void IDataContainer_RaisesCollectionChangedOnClear()
{
IDataContainer A = DataContainerBuilder.Create()
.Data("A", 1)
.Data("B", 2)
.Build();
var listener = new CollectionChangedListener(A);
Assert.Null(listener.LastChange);
A.Clear();
Assert.NotNull(listener.LastChange);
Assert.Equal(NotifyCollectionChangedAction.Reset, listener.LastChange.Action);
}
public void IDataContainer_Intersect_UsesFirstsNameForResultName()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 22)
.Build();
IDataContainer B = DataContainerBuilder.Create("B")
.Data("A", 33)
.Build();
IDataContainer AintersectB = A.Intersect(B);
IDataContainer BintersectA = B.Intersect(A);
Assert.Equal(A.Name, AintersectB.Name);
Assert.Equal(B.Name, BintersectA.Name);
}
public void IDataContainer_Union_UsesFirstsNameForResultName()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 22)
.Build();
IDataContainer B = DataContainerBuilder.Create("B")
.Data("B", 33)
.Build();
IDataContainer AunionB = A.Union(B);
IDataContainer BunionA = B.Union(A);
Assert.Equal(A.Name, AunionB.Name);
Assert.Equal(B.Name, BunionA.Name);
}
public void DataContainerAutoUpdater_ShouldUpdateValuesWithMultiLevelData()
{
string path = Path.GetTempFileName();
DataContainerBase A = (DataContainerBase)DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("D", 3)
.DataContainer("AB", b => b
.Data("AB1", 1))
.Build();
A.FilePath = path;
A.SaveAsXml(path);
var tester = new AutoUpateTester(A);
tester.AutoUpdater.PollingInterval = 10;
Assert.False(tester.UpdateStartedInvoked);
Assert.False(tester.UpdateFinishedInvoked);
IDataContainer Updated = (DataContainerBase)DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("D", 3)
.DataContainer("AB", b => b
.Data("AB1", 2))
.Build();
Updated.SaveAsXml(path);
// wait timer
Thread.Sleep((int)tester.AutoUpdater.PollingInterval + 20);
Assert.True(tester.UpdateStartedInvoked);
Assert.True(tester.UpdateFinishedInvoked);
IDataContainer AB = (IDataContainer)A["AB"];
IDataContainer U_AB = (IDataContainer)Updated["AB"];
Assert.Equal(2, (int)AB["AB1"]);
Assert.Equal(U_AB["AB1"], AB["AB1"]);
File.Delete(path);
}
public void DataContainerAutoUpdater_ShouldAddNewValues()
{
string path = Path.GetTempFileName();
DataContainerBase A = (DataContainerBase)DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("D", 3)
.Build();
A.FilePath = path;
A.SaveAsXml(path);
var tester = new AutoUpateTester(A);
Assert.False(tester.UpdateStartedInvoked);
Assert.False(tester.UpdateFinishedInvoked);
// allow adding new items
tester.AutoUpdater.CanAddItems = true;
tester.AutoUpdater.PollingInterval = 10;
IDataContainer Updated = (DataContainerBase)DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("C", 3)
.Data("D", 5)
.Build();
Updated.SaveAsXml(path);
// wait timer
Thread.Sleep((int)tester.AutoUpdater.PollingInterval + 20);
Assert.True(tester.UpdateStartedInvoked);
Assert.True(tester.UpdateFinishedInvoked);
// 1 new property added
Assert.Equal(4, A.Count);
// new value is present
Assert.True(A.ContainsData("C"));
// has correct value
Assert.Equal(3, (int)A["C"]);
File.Delete(path);
}
public void SnapShot_ValuesShouldNotChangeWhenIDataContainerChanges()
{
IDataContainer A = (DataContainerBase)DataContainerBuilder.Create("A")
.Data("A", 1)
.Build();
SnapShot snapShot = A.GetSnapShot();
Assert.Single(snapShot);
Assert.Equal(A["A"], snapShot["A"].Value);
object origValue = A["A"];
A["A"] = 3;
Assert.NotEqual(A["A"], snapShot["A"].Value);
Assert.Equal(origValue, snapShot["A"].Value);
}
