public void FormatProviderTest(string cultureName)
{
// Arrange
var formatProvider = new CultureInfo(cultureName);
var serialization = new DefaultSerialization {
FormatProvider = formatProvider
};
var dummy = new DummyClass
{
Number = 1001,
SingleClass = new SubClass {
Foo = 1.1234f
}
};
// Act
var encoded = EntryConvert.EncodeObject(dummy, serialization);
var dummyDecoded = EntryConvert.CreateInstance <DummyClass>(encoded, serialization);
// Assert
Assert.AreEqual(1001.ToString(formatProvider), encoded.SubEntries[0].Value.Current);
Assert.AreEqual(1.1234f.ToString(formatProvider), encoded.SubEntries[3].SubEntries[0].Value.Current);
Assert.AreEqual(1001, dummyDecoded.Number);
Assert.AreEqual(1.1234f, dummyDecoded.SingleClass.Foo);
}
public void UpdatePrimitiveList()
{
// Arrange
var defaultSerialization = new DefaultSerialization {
FormatProvider = new CultureInfo("en-US")
};
var dummy = new ListDummy
{
Number = 0,
DoubleList = new List <double> {
1.7, 2.5, 3
},
EnumList = new List <DummyEnum> {
DummyEnum.ValueA, DummyEnum.Unset, DummyEnum.ValueB
}
};
var encoded = EntryConvert.EncodeObject(dummy, defaultSerialization);
var ent = encoded.SubEntries[1];
var ent2 = encoded.SubEntries[2];
// Act
encoded.SubEntries[0].Value.Current = "5";
ent.SubEntries[1].Value.Current = 12.34d.ToString(defaultSerialization.FormatProvider);
var newInstance = ent.Prototypes[0].Instantiate();
newInstance.Value.Current = 133.7d.ToString(defaultSerialization.FormatProvider);
ent.SubEntries.Add(newInstance);
ent2.SubEntries[1].Value.Current = "ValueB";
newInstance = ent2.Prototypes[0].Instantiate();
newInstance.Value.Current = "ValueA";
ent2.SubEntries.Add(newInstance);
EntryConvert.UpdateInstance(dummy, encoded, defaultSerialization);
// Assert
Assert.AreEqual(5, dummy.Number);
Assert.AreEqual(4, dummy.DoubleList.Count);
Assert.AreEqual(1.7, dummy.DoubleList[0]);
Assert.AreEqual(12.34, dummy.DoubleList[1]);
Assert.AreEqual(3.0, dummy.DoubleList[2]);
Assert.AreEqual(133.7, dummy.DoubleList[3]);
Assert.AreEqual(4, dummy.EnumList.Count);
Assert.AreEqual(DummyEnum.ValueA, dummy.EnumList[0]);
Assert.AreEqual(DummyEnum.ValueB, dummy.EnumList[1]);
Assert.AreEqual(DummyEnum.ValueB, dummy.EnumList[2]);
Assert.AreEqual(DummyEnum.ValueA, dummy.EnumList[3]);
}
public void CreateInstance()
{
// Arrange
var defaultSerialization = new DefaultSerialization();
var encoded = EntryConvert.EncodeClass(typeof(DummyClass), defaultSerialization);
// Act
encoded.SubEntries[0].Value.Current = "10";
encoded.SubEntries[1].Value.Current = "Thomas";
encoded.SubEntries[3].SubEntries[1].Value.Current = encoded.SubEntries[3].SubEntries[1].Value.Possible[2];
for (var i = 4; i < 7; i++)
{
var colEntry = encoded.SubEntries[i];
for (var j = 0; j < i; j++)
{
var newInstance = colEntry.Prototypes[0].Instantiate();
newInstance.SubEntries[0].Value.Current = j.ToString("F2", defaultSerialization.FormatProvider);
newInstance.SubEntries[1].Value.Current = newInstance.SubEntries[1].Value.Possible[1];
colEntry.SubEntries.Add(newInstance);
}
}
var obj = EntryConvert.CreateInstance <DummyClass>(encoded);
// Assert
Assert.AreEqual(10, obj.Number);
Assert.AreEqual("Thomas", obj.Name);
Assert.AreEqual(DummyEnum.ValueB, obj.SingleClass.Enum);
var colAssert = new[] { CollectionType.Array, CollectionType.List, CollectionType.Enumerable };
for (var i = 0; i < colAssert.Length; i++)
{
var length = 4 + i;
var collection = ExtractCollection(colAssert[i], obj);
Assert.AreEqual(length, collection.Count);
if (colAssert[i] == CollectionType.Dictionary)
{
}
else
{
var array = (collection as IEnumerable <SubClass>).ToArray();
for (var j = 0; j < length; j++)
{
Assert.AreEqual((float)j, array[j].Foo);
Assert.AreEqual(DummyEnum.ValueA, array[j].Enum);
}
}
}
}
public void AddEntry(CollectionType type, int prefill, int newValues)
{
// Arrange
var defaultSerialization = new DefaultSerialization();
var obj = Prebuild(type, prefill);
var encoded = EntryConvert.EncodeObject(obj, defaultSerialization);
// Act
var colEntry = CollectionEntry(encoded.SubEntries, type);
if (type == CollectionType.Dictionary)
{
for (var i = 1; i <= newValues; i++)
{
var newInstance = colEntry.Prototypes[0].Instantiate();
// change "Key" + 10
newInstance.DisplayName = (prefill + i).ToString();
// change "Value"
newInstance.SubEntries[0].Value.Current = (prefill + i).ToString("F2", defaultSerialization.FormatProvider);
newInstance.SubEntries[1].Value.Current = newInstance.SubEntries[1].Value.Possible[2];
colEntry.SubEntries.Add(newInstance);
}
}
else
{
for (var i = 1; i <= newValues; i++)
{
var newInstance = colEntry.Prototypes[0].Instantiate();
newInstance.SubEntries[0].Value.Current = (prefill + i).ToString();
newInstance.SubEntries[1].Value.Current = newInstance.SubEntries[1].Value.Possible[2];
colEntry.SubEntries.Add(newInstance);
}
}
EntryConvert.UpdateInstance(obj, encoded);
// Assert
var collection = ExtractCollection(type, obj);
var totalSize = prefill + newValues;
Assert.AreEqual(totalSize, collection.Count, "New size invalid");
if (type == CollectionType.Dictionary)
{
var array = (collection as IEnumerable <KeyValuePair <int, SubClass> >).ToArray();
for (var i = 0; i < totalSize; i++)
{
Assert.AreEqual((float)i + 1, array[i].Key, "Key not set!");
Assert.AreEqual((float)i + 1, array[i].Value.Foo, "Value not set!");
var expectedEnum = i < prefill ? DummyEnum.ValueA : DummyEnum.ValueB;
Assert.AreEqual(expectedEnum, array[i].Value.Enum, "Enum not set");
}
}
else
{
var array = (collection as IEnumerable <SubClass>).ToArray();
for (var i = 0; i < totalSize; i++)
{
Assert.AreEqual((float)i + 1, array[i].Foo, "Value not set!");
var expectedEnum = i < prefill ? DummyEnum.ValueA : DummyEnum.ValueB;
Assert.AreEqual(expectedEnum, array[i].Enum, "Enum not set");
}
}
}
