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 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 BehavesLikeDefaultSerializerByDefault()
{
var result = serializer.Serialize(null, entity, context).Single();
var expected = defaultSerializer.Serialize(null, entity, context).Single();
Assert.That(result.ToString(), Is.EqualTo(expected.ToString()));
}
public void SerializeDefault()
{
IStandardSerializer <User> serializer = new DefaultSerializer <User>();
string user = serializer.Serialize(new User("Test", "test"));
Assert.AreEqual("Test test", user);
}
public void ChangeToDefaultSerializer()
{
DefaultSerializer <User> serializer = new DefaultSerializer <User>();
serializer.setBinding(System.Reflection.BindingFlags.NonPublic);//all fields are public so no fields return
serializer.Serialize(new User("Toto", "Titi"));
}
public void SerializeEmptyEnum()
{
var serializer = new DefaultSerializer();
var json = serializer.Serialize(new { test = new FactorStatus(string.Empty) });
json.Should().Be("{\"test\":\"\"}");
}
public void SerializeNullEnum()
{
var serializer = new DefaultSerializer();
var json = serializer.Serialize(new { test = new FactorStatus(null) });
json.Should().Be("{\"test\":\"\"}");
}
public void TagHelper_Serialization()
{
using (var stream = new MemoryStream())
using (var writer = new StreamWriter(stream, Encoding.UTF8, bufferSize: 4096))
{
DefaultSerializer.Serialize(writer, DefaultTagHelpers);
}
}
public void SerializeObject()
{
var serializer = new DefaultSerializer();
var json = serializer.Serialize(new { foo = "bar" });
json.Should().Be("{\"foo\":\"bar\"}");
}
public void SerializeObjectAndPreserveCase()
{
var serializer = new DefaultSerializer();
var json = serializer.Serialize(new { Foo = "bar" });
json.Should().Be("{\"Foo\":\"bar\"}");
}
public void SerializeEnum()
{
var serializer = new DefaultSerializer();
var json = serializer.Serialize(new { test = TestEnum.Foo });
json.Should().Be("{\"test\":\"FOO\"}");
}
public void SerializeEnum()
{
var serializer = new DefaultSerializer();
var json = serializer.Serialize(new { test = FactorStatus.Active });
json.Should().Be("{\"test\":\"ACTIVE\"}");
}
static string ConvertObjectToString(IEnumerable <OutboxOperation> operations)
{
if (operations == null || !operations.Any())
{
return(null);
}
return(DefaultSerializer.Serialize(operations));
}
public async Task Enqueue(IOutboundMessage message)
{
await DbSet.AddAsync(new OutboundMessage
{
Message = DefaultSerializer.Serialize(message),
Endpoint = message.Endpoint.Name,
Created = DateTime.UtcNow
});
}
private static void SerializeToFile(string path, object obj)
{
using (StreamWriter sw = new StreamWriter(File.Create(path)))
using (JsonTextWriter jtw = new JsonTextWriter(sw)
{
Formatting = Formatting.Indented, IndentChar = '\t', Indentation = 1
})
DefaultSerializer.Serialize(jtw, obj);
}
public static string ToYaml(object target)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
return(DefaultSerializer.Serialize(target));
}
public void SampleMessageFieldParams()
{
var defaultSerializer = new DefaultSerializer<SampleMessage>(this.messageRegistry, this.typeRegistry);
var d = new MessageDispatcher<SampleApiClass>(this.messageRegistry, this.typeRegistry);
using (var buf = new ThreadSafeWriteQueue(1024))
{
var orig = new SampleMessage { MessageId = defaultSerializer.MessageId, A = 10 };
defaultSerializer.Serialize(buf, orig);
var pos = buf.ReadMessage();
Assert.IsTrue(d.Dispatch(buf, pos, defaultSerializer.MessageId, new SampleApiClass()));
}
}
public void Add(object message, IEndpoint endpoint)
{
lock (_lock)
{
DbSet.Add(new InboundMessage
{
MessageId = _messageKeyProvider.GetKey(message),
Message = DefaultSerializer.Serialize(message),
EndpointName = endpoint.Name,
Consumed = DateTime.UtcNow
});
}
}
public Task Enqueue(IOutboundMessage message)
{
DbSet.Add(new OutboundMessage
{
Content = message.RawContent ?? message.Endpoint.Serializer.Serialize(message.Content, message.Headers),
Headers = DefaultSerializer.Serialize((IEnumerable <MessageHeader>)message.Headers),
Endpoint = DefaultSerializer.Serialize(message.Endpoint),
EndpointName = message.Endpoint.Name,
Created = DateTime.UtcNow
});
return(Task.CompletedTask);
}
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 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 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);
}
}
public void StripBrackets_EmptyList_RemovesBrackets()
{
//arrange
var serializer = new DefaultSerializer();
object values = new List <int> {
};
//act
var valuesBytes = serializer.Serialize(values);
var actual = valuesBytes.StripBrackets();
//assert
var expected = new byte[] { };
Assert.AreEqual(expected, actual);
}
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 StripBrackets_StringList_RemovesBrackets()
{
//arrange
var serializer = new DefaultSerializer();
object values = new List <string> {
"1", "2", "3", "4"
};
//act
var valuesBytes = serializer.Serialize(values);
var actual = valuesBytes.StripBrackets();
//assert
var expected = new byte[] { 0x22, 0x31, 0x22, 0x2c, 0x22, 0x32, 0x22, 0x2c, 0x22, 0x33, 0x22, 0x2c, 0x22, 0x34, 0x22 };
Assert.AreEqual(expected, actual);
}
public void StripBrackets_WhenString_DoesNothing()
{
//arrange
var serializer = new DefaultSerializer();
object values = "howdy pardner";
//act
var valuesBytes = serializer.Serialize(values);
var actual = valuesBytes.StripBrackets();
//assert
var expected = new byte[] {
0x22, 0x68, 0x6f, 0x77, 0x64, 0x79, 0x20, 0x70, 0x61, 0x72, 0x64, 0x6e, 0x65, 0x72, 0x22
};
Assert.AreEqual(expected, actual);
}
public void SerializeResourceWithCustomProperties()
{
var serializer = new DefaultSerializer();
var profile = new UserProfile
{
FirstName = "Foo",
};
profile["Custom"] = "Bar";
var user = new User
{
Profile = profile,
};
var json = serializer.Serialize(user);
json.Should().Be("{\"profile\":{\"firstName\":\"Foo\",\"Custom\":\"Bar\"}}");
}
public void SerializeResource()
{
var serializer = new DefaultSerializer();
var user = new User
{
Credentials = new UserCredentials
{
Password = new PasswordCredential
{
Value = "secret",
},
},
};
var json = serializer.Serialize(user);
json.Should().Be("{\"credentials\":{\"password\":{\"value\":\"secret\"}}}");
}
/// <summary>
/// Please note this is a shallow overwrite with no real sophistication past the root object.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="destination"></param>
/// <param name="source"></param>
public static void CopyFromObj <T>(this JObject destination, T source) where T : class
{
var serializer = new DefaultSerializer();
var json = serializer.Serialize(source);
var jobj = JObject.Parse(json);
foreach (var prop in jobj.Properties())
{
if (destination.Properties().Any(x => x.Name == prop.Name))
{
destination[prop.Name].Replace(jobj[prop.Name]);
}
else
{
destination.Add(prop.Name, jobj[prop.Name]);
}
}
}
public Task <string> GetBodyAsync(string href, CancellationToken ct)
{
var resources = _items
.Skip(_currentPage * _pageSize)
.Take(_pageSize)
.Cast <Resource>();
var itemData = resources
.Select(x => x.GetData())
.ToArray();
// Increment page
_currentPage++;
var serializer = new DefaultSerializer();
return(Task.FromResult(serializer.Serialize(itemData)));
}
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 async Task Add(object message, IEndpoint endpoint)
{
await _semaphore.WaitAsync();
try
{
DbSet.Add(new InboundMessage
{
MessageId = _messageKeyProvider.GetKey(message),
Message = DefaultSerializer.Serialize(message),
EndpointName = endpoint.Name,
Consumed = DateTime.UtcNow
});
}
finally
{
_semaphore.Release();
}
}
public void SerializeResource()
{
var serializer = new DefaultSerializer();
var nestedResource = new TestNestedResource()
{
Nested = new TestNestedResource()
{
Nested = new TestNestedResource()
{
Foo = "foobar",
}
}
};
var json = serializer.Serialize(nestedResource);
json.Should().Be("{\"nested\":{\"nested\":{\"foo\":\"foobar\"}}}");
}
public void StripBrackets_StringList_RemovesBrackets()
{
//arrange
var serializer = new DefaultSerializer();
object values = new List<string> { "1", "2", "3", "4" };
//act
var valuesBytes = serializer.Serialize(values);
var actual = valuesBytes.StripBrackets();
//assert
var expected = new byte[] {0x22, 0x31, 0x22, 0x2c, 0x22, 0x32, 0x22, 0x2c, 0x22, 0x33, 0x22, 0x2c, 0x22, 0x34, 0x22};
Assert.AreEqual(expected, actual);
}
public void StripBrackets_WhenString_DoesNothing()
{
//arrange
var serializer = new DefaultSerializer();
object values = "howdy pardner";
//act
var valuesBytes = serializer.Serialize(values);
var actual = valuesBytes.StripBrackets();
//assert
var expected = new byte[] {
0x22, 0x68, 0x6f, 0x77, 0x64, 0x79, 0x20, 0x70, 0x61, 0x72, 0x64, 0x6e, 0x65, 0x72, 0x22 };
Assert.AreEqual(expected, actual);
}
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);
}
}
public void StripBrackets_EmptyList_RemovesBrackets()
{
//arrange
var serializer = new DefaultSerializer();
object values = new List<int> { };
//act
var valuesBytes = serializer.Serialize(values);
var actual = valuesBytes.StripBrackets();
//assert
var expected = new byte[] { };
Assert.AreEqual(expected, actual);
}
