public void Should_be_able_to_serialize_and_deserialize_a_complex_type() { var complex = new ComplexSerializerType(); var serializer = new DefaultSerializer(); serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v1.SomeSerializerType)); serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v1.AnotherSerializerType)); serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v2.SomeSerializerType)); serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v2.AnotherSerializerType)); var stream = serializer.Serialize(complex); var xml = new StreamReader(stream).ReadToEnd(); Assert.IsTrue(xml.Contains(complex.Id.ToString())); stream.Position = 0; Assert.AreEqual(complex.Id, ((ComplexSerializerType)serializer.Deserialize(typeof(ComplexSerializerType), stream)).Id); Console.WriteLine(xml); var some1 = new v1.SomeSerializerType(); var some2 = new v2.SomeSerializerType(); Assert.AreEqual(some1.Id, ((v1.SomeSerializerType)serializer.Deserialize(typeof(v1.SomeSerializerType), serializer.Serialize(some1))).Id); Assert.AreEqual(some2.Id, ((v2.SomeSerializerType)serializer.Deserialize(typeof(v2.SomeSerializerType), serializer.Serialize(some2))).Id); }
private async Task test <T>(DefaultSerializer serializer, MockResolveProxyIds resolver, params T[] values) { Assert.IsTrue(serializer.CanSerialize(typeof(T))); foreach (var value in values) { var stream = new MemoryStream(); using (var writer = new BinaryWriter(stream, Encoding.UTF8, true)) { await serializer.Serialize(writer, typeof(T), value, resolver).ConfigureAwait(false); } Console.WriteLine($"Size of {value}: {stream.Length}"); stream.Position = 0; using (var reader = new BinaryReader(stream, Encoding.UTF8, true)) { var deserializedValue = await serializer.Deserialize(reader, typeof(T), resolver, CancellationToken.None).ConfigureAwait(false); Assert.AreEqual(value, deserializedValue); } } }
public void Deserialize_ByteArray_WithICustomObjectCreator_CreatesCustomObjects() { // Arrange var creator = new FakeCustomObjectCreator(); var settings = new JsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver() }; var serializer = new DefaultSerializer(settings, settings) { DeserializationOptions = new DeserializationOptions() { CustomObjectCreator = creator } }; var jsonBuffer = Encoding.UTF8.GetBytes("{\"subNode\":{\"property\":\"value\"}}"); // Act var result = serializer.Deserialize <JsonDocument>(jsonBuffer, 0, jsonBuffer.Length); // Assert Assert.NotNull(result); Assert.NotNull(result.SubNode); Assert.AreEqual(typeof(DocumentSubNodeInherited), result.SubNode.GetType()); Assert.AreEqual("value", result.SubNode.Property); }
public async Task Test() { var resolver = new MockResolveProxyIds(); var serializer = new DefaultSerializer(); Assert.IsTrue(serializer.CanSerialize(typeof(DateTime))); var values = new[] { DateTime.MinValue, DateTime.Today, DateTime.Now, DateTime.UtcNow, DateTime.MaxValue }; foreach (var value in values) { var stream = new MemoryStream(); using (var writer = new BinaryWriter(stream, Encoding.UTF8, true)) { await serializer.Serialize(writer, typeof(DateTime), value, resolver).ConfigureAwait(false); } Console.WriteLine($"Size of {value}: {stream.Length}"); stream.Position = 0; using (var reader = new BinaryReader(stream, Encoding.UTF8, true)) { var deserializedValue = await serializer.Deserialize(reader, typeof(DateTime), resolver, CancellationToken.None).ConfigureAwait(false); Assert.AreEqual(value, deserializedValue); } } }
public void Deserialize_Stream_WithICustomObjectCreator_CreatesCustomObjects() { // Arrange var creator = new FakeCustomObjectCreator(); var settings = new JsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver() }; var serializer = new DefaultSerializer(settings, settings) { DeserializationOptions = new DeserializationOptions() { CustomObjectCreator = creator } }; var stream = new MemoryStream(Encoding.UTF8.GetBytes("{\"subNode\":{\"property\":\"value\"}}")); // Act var result = serializer.Deserialize<JsonDocument>(stream); // Assert Assert.NotNull(result); Assert.NotNull(result.SubNode); Assert.AreEqual(typeof(DocumentSubNodeInherited), result.SubNode.GetType()); Assert.AreEqual("value", result.SubNode.Property); }
public void DeserializeNullInput() { var serializer = new DefaultSerializer(); var dict = serializer.Deserialize(null); dict.Count.Should().Be(0); }
public void DeserializeEmptyInput() { var serializer = new DefaultSerializer(); var dict = serializer.Deserialize(string.Empty); dict.Count.Should().Be(0); }
public void DeserializeDefault() { IStandardSerializer <User> serializer = new DefaultSerializer <User>(); User user = serializer.Deserialize("Test test"); Assert.AreEqual("Test", user.Name); Assert.AreEqual("test", user.Firstname); }
public void TagHelper_Deserialization() { // Deserialize from json file. IReadOnlyList <TagHelperDescriptor> tagHelpers; using var stream = new MemoryStream(_tagHelperBuffer); using var reader = new JsonTextReader(new StreamReader(stream)); tagHelpers = DefaultSerializer.Deserialize <IReadOnlyList <TagHelperDescriptor> >(reader); }
public async Task <IEnumerable <QueuedMessage> > Dequeue(int count) => (await DbSet .Where(m => m.Produced == null) .OrderBy(m => m.Id) .Take(count) .ToListAsync()) .Select(message => new DbQueuedMessage( message.Id, DefaultSerializer.Deserialize <IOutboundMessage>(message.Message)));
public async Task <IEnumerable <QueuedMessage> > Dequeue(int count) => (await DbSet.AsQueryable() .Where(m => m.Produced == null) .OrderBy(m => m.Id) .Take(count) .ToListAsync()) .Select(message => new DbQueuedMessage( message.Id, message.Content, DefaultSerializer.Deserialize <IEnumerable <MessageHeader> >(message.Headers), DefaultSerializer.Deserialize <IEndpoint>(message.Endpoint)));
public static IConfiguration From(string xml, Encoding encoding) { Guard.AgainstNullOrEmptyString(xml, nameof(xml)); Guard.AgainstNull(encoding, nameof(encoding)); var serializer = new DefaultSerializer(); using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(xml))) { return((IConfiguration)serializer.Deserialize(typeof(DefaultConfiguration), stream)); } }
public void BinarySerialization() { var reg = new MessageRegistry(); var ser = new DefaultSerializer<SubMessage>(reg, new TypeRegistry( new[] { TypeRegistry.StandartTypes, new[] { new VectorXYZBinarySerializer() }})); using (var buf = new ThreadSafeWriteQueue(1024)) { var src = new SubMessage { Vector3 = new Vector3(1.1f, 2.2f, 3.3f) }; ser.Serialize(buf, src); var dst = new SubMessage(); ser.Deserialize(buf, buf.ReadMessage(), dst); Assert.AreEqual(src.Vector3, dst.Vector3); } }
public void DeserializeDictionaries() { var json = @" { ""foo"": ""bar"", ""baz"": 123 }"; var serializer = new DefaultSerializer(); var dict = serializer.Deserialize(json); dict["foo"].Should().Be("bar"); dict["baz"].Should().Be(123L); }
public void Should_be_able_to_serialize_and_deserialize_a_simple_type() { var original = new SimpleSerializerType(); var serializer = new DefaultSerializer(); var stream = serializer.Serialize(original); var xml = new StreamReader(stream).ReadToEnd(); Assert.IsTrue(xml.Contains(original.Id.ToString())); stream.Position = 0; Assert.AreEqual(original.Id, ((SimpleSerializerType)serializer.Deserialize(typeof(SimpleSerializerType), stream)).Id); }
public void DeserializeDateAsString() { var date = DateTimeOffset.UtcNow; var json = $@" {{ ""foo"": ""{date}"", }}"; var serializer = new DefaultSerializer(); var dict = serializer.Deserialize(json); dict["foo"].Should().Be(date.ToString()); dict["foo"].GetType().Should().Be(typeof(string)); }
public void EmptyString() { var r = new DefaultSerializer<SubMessage>(this.messageRegistry, this.typeRegistry); using (var buf = new ThreadSafeWriteQueue(1024)) { var orig = new SubMessage { Text = string.Empty, }; r.Serialize(buf, orig); SubMessage message = new SubMessage(); r.Deserialize(buf, buf.ReadMessage(), message); Assert.AreEqual(orig.MessageId, message.MessageId); Assert.IsTrue(string.IsNullOrEmpty(message.Text)); } }
public void TestVec4() { var r = new DefaultSerializer<SingleMessage<Vector4>>(this.messageRegistry, this.typeRegistry,4); using (var buf = new ThreadSafeWriteQueue(1024)) { var orig = new SingleMessage<Vector4> { MessageId = r.MessageId, A = new Vector4(1.1f, 2.2f, 3.3f,( 4.4f)) }; r.Serialize(buf, orig); SingleMessage<Vector4> message = new SingleMessage<Vector4>(); r.Deserialize(buf, buf.ReadMessage(), message); Assert.AreEqual(orig.MessageId, message.MessageId); Assert.AreEqual(orig.A, message.A); } }
/// <summary> /// Deserialize an object from a file in the working folder. /// /// <para> /// Rethrows any exceptions that occur during deserialization. /// </para> /// /// </summary> /// <typeparam name="T">Type of the object being deserialized.</typeparam> /// <param name="filename">Name of the file holding the serialized object.</param> /// <returns>An object reconstructed from the data in the file.</returns> public T Deserialize <T>(string filename) { using (StreamReader sr = new StreamReader(GetPath(filename))) using (JsonReader reader = new JsonTextReader(sr)) { try { return(DefaultSerializer.Deserialize <T>(reader)); } catch (JsonException e) { // Hide JSON implementation details. throw new Exception(e.Message); } } }
public void DeserializeNestedDictionaries() { var json = @" { ""foo"": ""bar"", ""baz"": { ""qux"": 123 } }"; var serializer = new DefaultSerializer(); var dict = serializer.Deserialize(json); dict["foo"].Should().Be("bar"); dict["baz"].Should().BeAssignableTo <IReadOnlyDictionary <string, object> >(); (dict["baz"] as IReadOnlyDictionary <string, object>)["qux"].Should().Be(123L); }
public void DeserializeArraysAsLists() { var json = @" { ""things"": [ ""foo"", ""bar"", ""baz"" ] }"; var serializer = new DefaultSerializer(); var dict = serializer.Deserialize(json); dict["things"].Should().NotBeNull(); var things = dict["things"] as IList <object>; things.OfType <string>().Should().BeEquivalentTo("foo", "bar", "baz"); }
public async Task Test() { var resolver = new MockResolveProxyIds(); var serializer = new DefaultSerializer(); var stream = new MemoryStream(); var str = new string(new[] { char.MinValue, //standard ASCII 'A', 'Z', 'a', 'z', //extended ASCII 'À', 'Ï', //unicode 'Ā', 'ď', char.MaxValue }); using (var writer = new BinaryWriter(stream, Encoding.UTF8, true)) { await serializer.Serialize(writer, typeof(string), str, resolver).ConfigureAwait(false); } Console.WriteLine($"Size of \"{str}\": {stream.Length}"); stream.Position = 0; using (var reader = new BinaryReader(stream, Encoding.UTF8, true)) { var deserializedValue = await serializer.Deserialize(reader, typeof(string), resolver, CancellationToken.None).ConfigureAwait(false); Assert.AreEqual(deserializedValue, str); } }
public void TagHelper_Serialization_RoundTrip() { // Serialize back to json. MemoryStream originalStream; using (originalStream = new MemoryStream()) using (var writer = new StreamWriter(originalStream, Encoding.UTF8, bufferSize: 4096)) { DefaultSerializer.Serialize(writer, DefaultTagHelpers); } IReadOnlyList <TagHelperDescriptor> reDeserializedTagHelpers; var stream = new MemoryStream(originalStream.GetBuffer()); using (stream) using (var reader = new JsonTextReader(new StreamReader(stream))) { reDeserializedTagHelpers = DefaultSerializer.Deserialize <IReadOnlyList <TagHelperDescriptor> >(reader); } }
public override IDisposable Subscribe(IObserver <IMessage <string, T> > observer) { RegisterOnCompleted(observer); return(this.Connection.On <string, string>(EventName, (meta, data) => { try { T metaData = DefaultSerializer.Deserialize <T>(meta); IMessage <string, T> message = new StringMessage <T>(data, metaData); observer.OnNext(message); } catch (Exception ex) { observer.OnError(ex); } })); }
private async Task test(DefaultSerializer serializer, MockResolveProxyIds resolver, object value) { var stream = new MemoryStream(); using (var writer = new BinaryWriter(stream, Encoding.UTF8, true)) { await serializer.Serialize(writer, typeof(object), value, resolver).ConfigureAwait(false); } Console.WriteLine($"Size of {value}: {stream.Length}"); stream.Position = 0; using (var reader = new BinaryReader(stream, Encoding.UTF8, true)) { var deserializedValue = await serializer.Deserialize(reader, typeof(object), resolver, CancellationToken.None).ConfigureAwait(false); Assert.AreEqual(deserializedValue, value); } }
private async Task test(DefaultSerializer serializer, MockResolveProxyIds resolver, Array value) { var arrayType = value.GetType(); Assert.IsTrue(serializer.CanSerialize(arrayType)); var stream = new MemoryStream(); using (var writer = new BinaryWriter(stream, Encoding.UTF8, true)) { await serializer.Serialize(writer, arrayType, value, resolver).ConfigureAwait(false); } Console.WriteLine($"Size of {value}: {stream.Length}"); stream.Position = 0; using (var reader = new BinaryReader(stream, Encoding.UTF8, true)) { var deserializedValue = await serializer.Deserialize(reader, arrayType, resolver, CancellationToken.None).ConfigureAwait(false) as Array; Assert.IsNotNull(deserializedValue); Assert.AreEqual(value.Rank, deserializedValue.Rank, "Ranks don't match."); for (var dimension = 0; dimension < value.Rank; dimension++) { Assert.AreEqual(value.GetLength(dimension), deserializedValue.GetLength(dimension), $"Lengths ({dimension}) don't match."); Assert.AreEqual(value.GetLowerBound(dimension), deserializedValue.GetLowerBound(dimension), $"Lower bounds ({dimension}) don't match."); Assert.AreEqual(value.GetUpperBound(dimension), deserializedValue.GetUpperBound(dimension), $"Upper bounds ({dimension}) don't match."); } var enumerator = value.GetEnumerator(); var deserializedEnumerator = deserializedValue.GetEnumerator(); while (enumerator.MoveNext()) { Assert.IsTrue(deserializedEnumerator.MoveNext()); Assert.AreEqual(enumerator.Current, deserializedEnumerator.Current); } Assert.IsFalse(deserializedEnumerator.MoveNext()); } }
public async Task Test() { var resolver = new MockResolveProxyIds(); var serializer = new DefaultSerializer(); var stream = new MemoryStream(); using (var writer = new BinaryWriter(stream, Encoding.UTF8, true)) { await serializer.Serialize(writer, typeof(object), null, resolver).ConfigureAwait(false); } Console.WriteLine($"Size: {stream.Length}"); stream.Position = 0; using (var reader = new BinaryReader(stream, Encoding.UTF8, true)) { var deserializedValue = await serializer.Deserialize(reader, typeof(object), resolver, CancellationToken.None).ConfigureAwait(false); Assert.IsNull(deserializedValue); } }
public void DeserializeThrowsArgumentNullException() { var ex = Assert.Throws <ArgumentNullException>(() => m_serializer.Deserialize <MimeEntity>((byte[])null)); Assert.Equal("messageBytes", ex.ParamName); }
public void DeserializeToObject() { var result = serializer.Deserialize( serializer.Serialize(new object()), typeof(object) ).ShouldBeOfType <object>(); }
public void ThreeBytesString() { var r = new DefaultSerializer<SubMessage>(this.messageRegistry, this.typeRegistry); using (var buf = new ThreadSafeWriteQueue(1024)) { var orig = new SubMessage { Text = "aaa", }; r.Serialize(buf, orig); r.Serialize(buf, orig); SubMessage message = new SubMessage(); r.Deserialize(buf, buf.ReadMessage(), message); Assert.AreEqual(orig.MessageId, message.MessageId); Assert.AreEqual(orig.Text, message.Text); r.Deserialize(buf, buf.ReadMessage(), message); Assert.AreEqual(orig.MessageId, message.MessageId); Assert.AreEqual(orig.Text, message.Text); } }
public void TwoMessages() { var r = new DefaultSerializer<SubMessage>(this.messageRegistry, this.typeRegistry); using (var buf = new ThreadSafeWriteQueue(1024)) { var orig = new SubMessage { MessageId = int.MaxValue, A = int.MinValue, B = float.Epsilon, C = uint.MinValue, Byte = 1, Text = "aaaвпаав", }; var orig2 = new SubMessage { MessageId = int.MaxValue, A = int.MaxValue, B = float.MaxValue, C = uint.MaxValue, Byte = 255, Text = "впаавzz", }; r.Serialize(buf, orig); r.Serialize(buf, orig2); SubMessage message = new SubMessage(); r.Deserialize(buf, buf.ReadMessage(), message); Assert.AreEqual(orig.MessageId, message.MessageId); Assert.AreEqual(orig.A, message.A); Assert.AreEqual(orig.B, message.B); Assert.AreEqual(orig.C, message.C); Assert.AreEqual(orig.Text, message.Text); r.Deserialize(buf, buf.ReadMessage(), message); Assert.AreEqual(orig2.MessageId, message.MessageId); Assert.AreEqual(orig2.A, message.A); Assert.AreEqual(orig2.B, message.B); Assert.AreEqual(orig2.C, message.C); Assert.AreEqual(orig2.Text, message.Text); } }
private async Task HandleApplicationMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs eventArgs) { if (!eventArgs.ApplicationMessage.Topic.Contains(GetRequestTopic(null, null))) { return; } var message = eventArgs.ApplicationMessage; var methodName = message.GetUserProperty("Method"); var id = message.GetUserProperty("Id"); var timeout = message.GetUserProperty <int?>("Timeout"); var broadcast = message.GetUserProperty <bool?>("Broadcast") ?? false; var noResponse = message.GetUserProperty <bool?>("NoResponse") ?? false; var clientId = GetSource(message.Topic); using var serviceScope = _serviceProvider.CreateScope(); using var cts = timeout.HasValue ? new CancellationTokenSource(timeout.Value * 1000) : new CancellationTokenSource(); var responseBuilder = new MqttApplicationMessageBuilder() .WithContentType(DefaultSerializer.ContentType) .WithTopic(GetResponseTopic(GetSource(message.Topic))) .WithAtLeastOnceQoS(); if (broadcast) { responseBuilder.WithUserProperty("Broadcast", true.ToString()); } if (timeout > 0) { responseBuilder.WithMessageExpiryInterval((uint)timeout.Value); } try { if (!RpcMethodResolver.Methods.TryGetValue(methodName, out var method)) { if (string.IsNullOrEmpty(id) || noResponse) { return; } throw new EntryPointNotFoundException($"Method '{methodName}' not found."); } var parameters = method.GetParameters(); object[] args; switch (parameters.Length) { case 0: args = null; break; case 1: var parameterInfo = parameters.First(); args = parameterInfo.ParameterType == typeof(byte[]) ? new[] { (object)message.Payload } : new[] { DefaultSerializer.Deserialize(message.Payload, parameterInfo.ParameterType) }; break; default: _logger.Error(new NotImplementedException(), "Multiple parameters resolving has not been supported yet, please use a key-value object."); return; } var rpcService = (IRpcService)serviceScope.ServiceProvider.GetService(method.DeclaringType); rpcService.CurrentContext = new RpcContext { Topic = message.Topic, RemoteClientId = clientId }; var task = Task.Run(async() => { var returnValue = method.Invoke(rpcService, args); if (returnValue is Task t) { await t.ConfigureAwait(false); if (t.GetType().IsGenericType) { var resultProperty = t.GetType().GetProperty("Result"); Debug.Assert(resultProperty != null); returnValue = resultProperty.GetValue(t); } } return(returnValue); }, cts.Token); if (!string.IsNullOrEmpty(id)) { if (!_waitingCalls.TryAdd(id, new CancellableTask(task, cts))) { throw new InvalidOperationException(); } } else { _noIdCalls.TryAdd(cts, task); } var result = await task.ConfigureAwait(false); responseBuilder.WithUserProperty("Success", true.ToString()); if (!noResponse) { responseBuilder.WithUserProperty("Id", id) .WithPayload(DefaultSerializer.Serialize(result)); } } catch (Exception ex) { responseBuilder.WithUserProperty("Success", false.ToString()) .WithUserProperty("ErrorCode", ex.HResult.ToString()) .WithUserProperty("ErrorMessage", ex.Message); } finally { if (!string.IsNullOrEmpty(id)) { _waitingCalls.TryRemove(id, out _); } else { _noIdCalls.TryRemove(cts, out _); } if (!noResponse) { await _mqttClient.PublishAsync(responseBuilder.Build()).ConfigureAwait(false); } } }
public void GetErrorMessageFromFormValidationError() { #region response objects var responseWithErrorMessage = @"{ ""remediation"": { ""type"": ""array"", ""value"": [ { ""rel"": [ ""create-form"" ], ""name"": ""reset-authenticator"", ""relatesTo"": [ ""$.currentAuthenticator"" ], ""href"": "".................."", ""method"": ""POST"", ""produces"": ""application/ion+json; okta-version=1.0.0"", ""value"": [ { ""name"": ""credentials"", ""type"": ""object"", ""form"": { ""value"": [ { ""name"": ""passcode"", ""label"": ""New password"", ""secret"": true, ""messages"": { ""type"": ""array"", ""value"": [ { ""message"": ""Error Message"", ""i18n"": { ""key"": ""password.passwordRequirementsNotMet"", ""params"": [ ""Password requirements: at least 8 characters,"" ] }, ""class"": ""ERROR"" } ] } } ] }, ""required"": true } ], ""accepts"": ""application/json; okta-version=1.0.0"" } ] } }"; var responseWithNoErrors = @"{ ""remediation"": { ""type"": ""array"", ""value"": [ { ""rel"": [ ""create-form"" ], ""name"": ""reset-authenticator"", ""relatesTo"": [ ""$.currentAuthenticator"" ], ""value"": [ { ""form"": { ""value"": [ { ""name"": ""passcode"", ""label"": ""New password"", ""secret"": true, } ] }, ""required"": true } ], ""accepts"": ""application/json; okta-version=1.0.0"" } ] } }"; #endregion response objects var serializer = new DefaultSerializer(); var resourseFactory = new ResourceFactory(null, null, null); var errorData = serializer.Deserialize(responseWithErrorMessage); var errorObject = resourseFactory.CreateNew <IonApiError>(errorData); errorObject.ErrorSummary.Should().Be("Error Message"); errorData = serializer.Deserialize(responseWithNoErrors); errorObject = resourseFactory.CreateNew <IonApiError>(errorData); errorObject.ErrorSummary.Should().BeNullOrEmpty(); errorData = serializer.Deserialize("{ }"); errorObject = resourseFactory.CreateNew <IonApiError>(errorData); errorObject.ErrorSummary.Should().BeNullOrEmpty(); }