public void NullableTest1(int?value)
{
using var stream = new MemoryStream();
BinaronConvert.Serialize(value, stream);
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(value, BinaronConvert.Deserialize <int?>(stream));
}
public void CustomInvalidNonConcreteTest <TSource>(TSource source, Type destType)
{
using var stream = new MemoryStream();
BinaronConvert.Serialize(source, stream);
stream.Seek(0, SeekOrigin.Begin);
Assert.Throws <NotSupportedException>(() => Converter.Deserialize(destType, stream));
}
private static void BinaronTest_Serialize <T>(T input, int loop)
{
using var stream = new MemoryStream();
for (var i = 0; i < loop; i++)
{
BinaronConvert.Serialize(input, stream, new SerializerOptions {
SkipNullValues = true
});
stream.Position = 0;
}
}
private static void BinaronTest_Validate <T>(T input, Action <T> validate)
{
using var stream = new MemoryStream();
BinaronConvert.Serialize(input, stream, new SerializerOptions {
SkipNullValues = true
});
stream.Position = 0;
var value = BinaronConvert.Deserialize <T>(stream);
validate(value);
}
public void DeserializeToDateTimeLocal()
{
var dt = DateTime.Now;
using var stream = new MemoryStream();
BinaronConvert.Serialize(dt, stream);
stream.Seek(0, SeekOrigin.Begin);
var dest = BinaronConvert.Deserialize <DateTime>(stream, new DeserializerOptions {
TimeZoneInfo = TimeZoneInfo.Local
});
Assert.AreEqual(dt, dest);
}
public void MemberSetterNullableType1(int?v1, string v2)
{
var tc1 = new TestClass1 {
IntValue = v1, StringValue = v2
};
using var stream = new MemoryStream();
BinaronConvert.Serialize(tc1, stream);
stream.Seek(0, SeekOrigin.Begin);
var tc2 = BinaronConvert.Deserialize <TestClass1>(stream);
Assert.AreEqual(v1, tc2.IntValue);
Assert.AreEqual(v2, tc2.StringValue);
}
public void EnumerableObjectEnumerableTest()
{
var multiLevelEnumerables = new InnerMultiLevelEnumerablesTestClass().Yield();
using var stream = new MemoryStream();
BinaronConvert.Serialize(multiLevelEnumerables, stream, new SerializerOptions {
SkipNullValues = true
});
stream.Position = 0;
var response = BinaronConvert.Deserialize <IEnumerable <InnerMultiLevelEnumerablesTestClass> >(stream);
var inner = response.First();
CollectionAssert.AreEqual(Enumerable.Range(0, 2), inner.MultiLevelEnumerables.First());
CollectionAssert.AreEqual(Enumerable.Range(3, 4), inner.MultiLevelEnumerables.Last());
}
public void RootReadOnlyDictionaryTests(Type destType)
{
IReadOnlyDictionary <string, string> source = new Dictionary <string, string> {
{ "a key", "a value" }
};
using var stream = new MemoryStream();
BinaronConvert.Serialize(source, stream);
stream.Seek(0, SeekOrigin.Begin);
var dest = (IEnumerable)Converter.Deserialize(destType, stream);
stream.Seek(0, SeekOrigin.Begin);
var dest2 = (IEnumerable)BinaronConvert.Deserialize(stream);
Assert.AreEqual(1, dest.Count());
Assert.AreEqual(1, dest2.Count());
}
public void ObjectActivatorTest()
{
const int testVal = 100;
var val = new TestClass <int?>();
using var stream = new MemoryStream();
BinaronConvert.Serialize(val, stream, new SerializerOptions {
SkipNullValues = true
});
stream.Seek(0, SeekOrigin.Begin);
var dest = BinaronConvert.Deserialize <TestClass <int?> >(stream, new DeserializerOptions {
ObjectActivator = new MyObjectActivator(testVal)
});
Assert.AreEqual(testVal, dest.Value);
}
public void ServiceProviderObjectActivatorTest()
{
var services = new ServiceCollection();
services.AddSingleton(new BaseConfig());
var obj = new
{
Score = 1.0d,
Numbers = new[] { 3, 2, 1 },
Dict = new
{
A = "a",
B = "b"
},
Ids = new[] { "Id1", "Id2" },
SubConfig = new
{
Numbers = new[] { 3, 2, 1 },
Dict = new
{
A = "a",
B = "b"
},
Ids = new[] { "Id1", "Id2" },
Extra = "extra"
}
};
var serviceProvider = services.BuildServiceProvider();
using var stream = new MemoryStream();
BinaronConvert.Serialize(obj, stream, new SerializerOptions {
SkipNullValues = true
});
stream.Position = 0;
var result = BinaronConvert.Deserialize <TestConfig>(stream, new DeserializerOptions {
ObjectActivator = new ObjectActivator(serviceProvider)
});
Assert.AreEqual(obj.SubConfig.Ids, result.SubConfig.Ids);
}
public void TestListOfNullables2()
{
var collection = new List <int?>()
{
1, null, 2
};
using (var ms1 = new MemoryStream())
{
var so = new SerializerOptions();
BinaronConvert.Serialize(collection, ms1, so);
using (var ms2 = new MemoryStream(ms1.ToArray()))
{
var cr2 = BinaronConvert.Deserialize <List <int?> >(ms2);
Assert.AreEqual(3, cr2.Count);
Assert.AreEqual(1, cr2[0]);
Assert.AreEqual(null, cr2[1]);
Assert.AreEqual(2, cr2[2]);
}
}
}
public void PopulateObjectTest()
{
const int testVal = 100;
var val = new TestClass <int?> {
RootValue = DateTime.MinValue
};
using var stream = new MemoryStream();
BinaronConvert.Serialize(val, stream, new SerializerOptions {
SkipNullValues = true
});
stream.Seek(0, SeekOrigin.Begin);
var dest = new TestClass <int?> {
Value = 100
};
BinaronConvert.Populate(dest, stream);
Assert.AreEqual(testVal, dest.Value);
Assert.AreEqual(DateTime.MinValue, dest.RootValue);
}
public void CustomInvalidNonConcreteTest <TSource>(TSource source, Type destType)
{
using var stream = new MemoryStream();
BinaronConvert.Serialize(source, stream);
stream.Seek(0, SeekOrigin.Begin);
Assert.Throws <NotSupportedException>(() =>
{
try
{
Converter.Deserialize(destType, stream);
}
catch (TypeInitializationException ex)
{
if (ex.InnerException is NotSupportedException)
{
throw ex.InnerException;
}
throw;
}
});
}
public async Task MultiLevelWithCustomFactoryTest()
{
var obj = CreatedNestedStructure();
await using var stream = new MemoryStream();
BinaronConvert.Serialize(obj, stream, new SerializerOptions {
SkipNullValues = true, CustomObjectIdentifierProviders = { new NodeObjectIdentifierProvider() }
});
stream.Position = 0;
var result = BinaronConvert.Deserialize <Nested>(stream, new DeserializerOptions {
CustomObjectFactories = { new NodeObjectFactory() }
});
stream.Position = 0;
dynamic dynamicResult = BinaronConvert.Deserialize(stream);
Assert.IsNull(result.Annotation1);
Assert.IsNull(result.Annotation2);
var derived1 = (DerivedNode)result.Nodes["One"];
var derived2 = (DerivedNode)result.Nodes["Two"];
Assert.AreEqual("some attributes", derived1.UserAttributes["attribute1"].SingleOrDefault());
CollectionAssert.AreEqual(new [] { "Child1", "Child2", "Child3" }, derived1.Values[0].SelectedChildren.Select(element => element.Name));
CollectionAssert.AreEqual(new [] { "Child4", "Child5" }, derived1.Values[1].SelectedChildren.Select(element => element.Name));
Assert.AreEqual(true, derived2.IsSelected);
var value = derived2.Values.SingleOrDefault();
Assert.NotNull(value);
Assert.AreEqual(100, value.Count);
var innerNestedNode = value.InnerNested.Nodes["InnerNode1"];
Assert.AreEqual("InnerDerivedNode1", innerNestedNode.Name);
Assert.AreEqual(true, ((DerivedNode)innerNestedNode).IsSelected);
Assert.NotNull(dynamicResult.Nodes["One"]);
}
