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)); }
public void ClassesAndStructsInListTest <TType>(IList <TType> _) where TType : Tester.ITestBase, new() { // Empty { using var stream = new MemoryStream(); BinaronConvert.Serialize(new TType[0], stream); stream.Seek(0, SeekOrigin.Begin); var dest = BinaronConvert.Deserialize <TType[]>(stream); stream.Seek(0, SeekOrigin.Begin); var dest2 = (IEnumerable)BinaronConvert.Deserialize(stream); Assert.AreEqual(0, dest.Length); Assert.AreEqual(0, dest2.Count()); } // Single { using var stream = new MemoryStream(); BinaronConvert.Serialize(new[] { new TType { Value = 1 } }, stream); stream.Seek(0, SeekOrigin.Begin); var dest = BinaronConvert.Deserialize <TType[]>(stream); stream.Seek(0, SeekOrigin.Begin); var dest2 = ((IEnumerable)BinaronConvert.Deserialize(stream)).ToArray(); Assert.AreEqual(1, dest.Length); Assert.AreEqual(1, dest.Single().Value); Assert.AreEqual(1, dest2.Length); Assert.AreEqual(1, ((dynamic)dest2.Single()).Value); } // Multi { using var stream = new MemoryStream(); BinaronConvert.Serialize(new[] { new TType { Value = 1 }, new TType { Value = 2 }, new TType { Value = 3 } }, stream); stream.Seek(0, SeekOrigin.Begin); var dest = BinaronConvert.Deserialize <TType[]>(stream); Assert.AreEqual(3, dest.Length); stream.Seek(0, SeekOrigin.Begin); var dest2 = ((IEnumerable)BinaronConvert.Deserialize(stream)).ToArray(); Assert.AreEqual(3, dest2.Length); { var expected = 0; foreach (var item in dest) { Assert.AreEqual(++expected, item.Value); } } { var expected = 0; foreach (dynamic item in dest2) { Assert.AreEqual(++expected, item.Value); } } } }
public static T TestRoundTrip <T>(object val, SerializerOptions options) { using var stream = new MemoryStream(); BinaronConvert.Serialize(val, stream, options); stream.Seek(0, SeekOrigin.Begin); return(BinaronConvert.Deserialize <T>(stream)); }
private void DumpToBinaryFile(GeoMapData data) { if (File.Exists(options.BinaryFile)) { File.Delete(options.BinaryFile); } using var stream = File.Open(options.BinaryFile, FileMode.CreateNew); BinaronConvert.Serialize(data, 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 static (T, object) TestRoundTrip2 <T>(object val, SerializerOptions options) { using var stream = new MemoryStream(); BinaronConvert.Serialize(val, stream, options); stream.Seek(0, SeekOrigin.Begin); var result1 = BinaronConvert.Deserialize <T>(stream); stream.Seek(0, SeekOrigin.Begin); var result2 = BinaronConvert.Deserialize(stream); return(result1, result2); }
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); }
private static void BinaronTest() { using var stream = new MemoryStream(); for (var i = 0; i < 50; i++) { BinaronConvert.Serialize(Source, stream, new SerializerOptions { SkipNullValues = true }); stream.Position = 0; var book = BinaronConvert.Deserialize <Book>(stream); stream.Position = 0; Trace.Assert(book.Title != null); } }
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 ClassWithReadOnlyDictionaryTest() { var source = new ClassWithReadOnlyDictionary { Dictionary = new Dictionary <string, object> { { "a key", "a value" } } }; using var stream = new MemoryStream(); BinaronConvert.Serialize(source, stream); stream.Seek(0, SeekOrigin.Begin); dynamic dest = BinaronConvert.Deserialize(stream); Assert.AreEqual("a value", ((IDictionary <string, object>)dest.Dictionary)["a key"]); }
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()); }
private static void BinaronTest_Deserialize <T>(T input, int loop) { var serializerOptions = new SerializerOptions { SkipNullValues = true }; using var stream = new MemoryStream(); BinaronConvert.Serialize(input, stream, serializerOptions); stream.Position = 0; for (var i = 0; i < loop; i++) { var _ = BinaronConvert.Deserialize <T>(stream); stream.Position = 0; } }
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 RootListTest <TSourceItem>(Type sourceType, Type destType, object list, TSourceItem sourceItem, object destItem) { var source = list.DynamicCast(sourceType); if (source == null) { throw new InvalidCastException($"Bad test case. Can't cast source with type of '{list.GetType()}' to '{sourceType}'"); } // Empty { 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(0, dest.Count()); Assert.AreEqual(0, dest2.Count()); } // Single { source = AddItem <TSourceItem>(sourceType, sourceItem, source); 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(!IsValid(sourceItem, destItem, destType) ? 0 : 1, dest.Count()); Assert.AreEqual(1, dest2.Count()); } // Multi { source = AddItem <TSourceItem>(sourceType, sourceItem, source); source = AddItem <TSourceItem>(sourceType, sourceItem, source); 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(!IsValid(sourceItem, destItem, destType) ? 0 : 3, dest.Count()); Assert.AreEqual(3, 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); }
private static Task BinaronTest() { var serializerOptions = new SerializerOptions { SkipNullValues = true }; using var stream = new MemoryStream(); for (var i = 0; i < Loop; i++) { BinaronConvert.Serialize(Source, stream, serializerOptions); stream.Position = 0; var book = BinaronConvert.Deserialize <Book>(stream); stream.Position = 0; Trace.Assert(book.Title != null); } return(Task.CompletedTask); }
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 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 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 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"]); }
public IGeoMap FromBinaryFile(string dataFile) { return(new GeoMapIndex(BinaronConvert.Deserialize <GeoMapData>(File.OpenRead(dataFile)))); }
public static void Build(string pak_name, string manifest_file_path) { AssetsPak pak = new AssetsPak(); BonFile manifest = BonFileReader.Parse(manifest_file_path); var output_path = Path.GetDirectoryName(manifest_file_path); Console.WriteLine($"Building PAK from manifest file: {manifest_file_path}"); Console.WriteLine("Parsed BON File:"); Console.WriteLine(manifest.ToString()); foreach (var section in manifest.Sections) { if (section.Key == "Root") { continue; } AssetTypes asset_type; Console.WriteLine($"Adding Asset: {section.Key}"); Console.WriteLine($"Type: {section.Value.ValueProps["type"].GetValue()}"); try { asset_type = (AssetTypes)Enum.Parse(typeof(AssetTypes), section.Value.ValueProps["type"].GetValue()); } catch (Exception) { throw new Exception("Unrecognized 'type' property or 'type' property is missing."); } if (!section.Value.ValueProps.ContainsKey("file_path")) { throw new Exception("Missing 'file_path' property."); } var asset_file_path = section.Value.ValueProps["file_path"].GetValue(); switch (asset_type) { case AssetTypes.Font: var font_image_path = Path.Combine(output_path, asset_file_path); var font_image = ResourceLoader.LoadImage(font_image_path); if (!section.Value.ValueProps.ContainsKey("glyph_size")) { throw new Exception("Missing 'glyph_size' property."); } var glyph_size = section.Value.ValueProps["glyph_size"].GetIntValue(); var font_data = new FontData() { GlyphSize = glyph_size, Id = section.Key, ImageData = font_image.ImageData, ImageWidth = font_image.Width, ImageHeight = font_image.Height }; pak.AddFont(font_data); break; case AssetTypes.SpriteSheet: var sheet_image_path = Path.Combine(output_path, asset_file_path); var sheet_image = ResourceLoader.LoadImage(sheet_image_path); if (!section.Value.ValueProps.ContainsKey("cell_size")) { throw new Exception("Missing 'cell_size' property."); } var cell_size = section.Value.ValueProps["cell_size"].GetIntValue(); Dictionary <string, int> sprite_map = new Dictionary <string, int>(); if (section.Value.ListProps.ContainsKey("sprites")) { var sprite_map_pairs = section.Value.ListProps["sprites"].Items; foreach (var sprite_map_pair in sprite_map_pairs) { if (!sprite_map_pair.Contains(':')) { continue; } var values = sprite_map_pair.Split(':'); sprite_map.Add(values[0], int.Parse(values[1])); } } var sheet_data = new SpriteSheetData() { Id = section.Key, CellSize = cell_size, ImageData = sheet_image.ImageData, ImageWidth = sheet_image.Width, ImageHeight = sheet_image.Height, SpriteMap = sprite_map }; pak.AddSheet(sheet_data); break; } } if (!pak_name.Contains(".pak")) { pak_name += ".pak"; } var pak_file_path = Path.Combine(output_path, pak_name); using var pak_output = File.OpenWrite(pak_file_path); BinaronConvert.Serialize(pak, pak_output); }
public static AssetsPak LoadPak(Stream stream) { var pak = BinaronConvert.Deserialize <AssetsPak>(stream); return(pak); }