public void Hirarchical_Integration_test()
{
MyComplexObject testObj = new MyComplexObject()
{
Name = "Root",
Value = 1,
runtimeThing = 30,// should not be preserved
ArrayOfInts = new int[] { 1, 2, 3, 4 },
ChildObject = new MyComplexObject()
{
Name = "branch",
Value = 3,
ArrayOfInts = new int[] { 999, 200 },
ArrayOfChildObject = new MyComplexObject[] {
new MyComplexObject()
{
Name = "1st ArrayItem"
},
new MyComplexObject()
{
Name = "2nd ArrayItem"
},
new MyComplexObject()
{
Name = "3rd ArrayItem, with more than 31 chars (extra byte needed)"
},
null,
new MyComplexObject()
{
Name = "5th ArrayItem, with a string that takes more than 255 bytes so we need two bytes to contain the length of this nice and lengthy example, and we are not there yet... well it is a little chatty example I must admit, but we'll get there eventually, maybe, Yes!"
},
}
},
Date = new DateTime(2021, 3, 5, 11, 32, 20),
NullableTypeWithValue = 3
};
byte[] buffer = MsgPackSerializer.Serialize(testObj);
MyComplexObject ret = MsgPackSerializer.Deserialize <MyComplexObject>(buffer);
Assert.AreEqual(testObj.Name, ret.Name);
Assert.AreEqual(testObj.Value, ret.Value);
Assert.AreNotEqual(testObj.runtimeThing, ret.runtimeThing);
Assert.AreEqual(testObj.ChildObject.Name, ret.ChildObject.Name);
Assert.AreEqual(testObj.ChildObject.ArrayOfChildObject[2].Name, ret.ChildObject.ArrayOfChildObject[2].Name);
Assert.AreEqual(testObj.ChildObject.ArrayOfChildObject[3], ret.ChildObject.ArrayOfChildObject[3]);
Assert.AreEqual(testObj.ChildObject.ArrayOfChildObject[4].Name, ret.ChildObject.ArrayOfChildObject[4].Name);
Assert.AreEqual(testObj.NullableType, ret.NullableType);
Assert.AreEqual(testObj.NullableTypeWithValue, ret.NullableTypeWithValue);
Assert.AreEqual(testObj.Date, ret.Date);
}
public void ComplexDictionary()
{
var tests = new Dictionary <object, object>
{
{
"array1",
new object[]
{
"array1_value1",
"array1_value2",
"array1_value3"
}
},
{ "bool1", true },
{ "double1", 50.5 },
{ "double2", 15.2 },
{ "int1", 50505 },
{ "int2", 50 },
{ 3.14f, 3.14 },
{ 42, 42 },
{ new Dictionary <int, int> {
{ 1, 2 }
}, null },
{ new[] { 1, 2 }, null }
};
var data = new byte[]
{
138,
166, 97, 114, 114, 97, 121, 49,
147,
173, 97, 114, 114, 97, 121, 49, 95, 118, 97, 108, 117, 101, 49,
173, 97, 114, 114, 97, 121, 49, 95, 118, 97, 108, 117, 101, 50,
173, 97, 114, 114, 97, 121, 49, 95, 118, 97, 108, 117, 101, 51,
165, 98, 111, 111, 108, 49, 195,
167, 100, 111, 117, 98, 108, 101, 49, 203, 64, 73, 64, 0, 0, 0, 0, 0,
167, 100, 111, 117, 98, 108, 101, 50, 203, 64, 46, 102, 102, 102, 102, 102, 102,
164, 105, 110, 116, 49, 205, 197, 73,
164, 105, 110, 116, 50, 50,
202, 64, 72, 245, 195, 203, 64, 9, 30, 184, 81, 235, 133, 31,
42, 42,
129, 1, 2, 192,
146, 1, 2, 192
};
var settings = new MsgPackContext();
settings.RegisterConverter(new TestReflectionConverter());
MsgPackSerializer.Serialize(tests, settings).ShouldBe(data);
Helpers.CheckTokenDeserialization(data);
}
private MemoryStream CreateAndSerializeHeader <TRequest>(
TRequest request,
RequestId requestId) where TRequest : IRequest
{
var stream = new MemoryStream();
var requestHeader = new RequestHeader(request.Code, requestId);
stream.Seek(Constants.PacketSizeBufferSize, SeekOrigin.Begin);
MsgPackSerializer.Serialize(requestHeader, stream, _msgPackContext);
return(stream);
}
public void MsgPack_Serialize_Deserialize_Test()
{
using (MsgPackSerializer serializer = new MsgPackSerializer())
{
Person person = new Person()
{
Id = 2, Name = "Jerry", Address = new Address()
};
byte[] buffer = serializer.Serialize(person);
Person _person = serializer.Deserialize <Person>(buffer);
Assert.Equal(person.Id, _person.Id);
Assert.Equal(person.Name, _person.Name);
MessagePack <Person> pack = new MessagePack <Person>(person);
buffer = serializer.Serialize(pack);
_person = serializer.Deserialize <MessagePack <Person> >(buffer)?.Message;
Assert.Equal(person.Id, _person.Id);
Assert.Equal(person.Name, _person.Name);
Packet packet = new Packet(typeof(Person).FullName, buffer, PacketType.Join, Guid.NewGuid().ToString());
buffer = serializer.Serialize(packet);
Packet _packet = serializer.Deserialize <Packet>(buffer);
Assert.Equal(packet.PackType, _packet.PackType);
Assert.Equal(packet.PacketType, _packet.PacketType);
Assert.Equal(packet.FromId, _packet.FromId);
_person = serializer.Deserialize <MessagePack <Person> >(_packet.Payload)?.Message;
Assert.Equal(person.Id, _person.Id);
Assert.Equal(person.Name, _person.Name);
}
}
public void WriteSmoke(ContextFixtureBase fixture)
{
var testObject = new BigImageInfo
{
Credits = Guid.NewGuid().ToString("N"),
Height = 123,
Link = Guid.NewGuid().ToString("N"),
Size = 234,
Width = 345
};
MsgPackSerializer.Serialize(testObject, fixture.NewContext).ShouldBe(MsgPackSerializer.Serialize(testObject, fixture.OldContext));
}
public void TestReadDataSourceSet()
{
const int NUM_SAMPLES = 10;
DataSourceSet dss;
var file = Path.GetTempFileName();
using (var stream = new FileStream(file, FileMode.Create, FileAccess.Write))
{
for (var i = 0; i < NUM_SAMPLES; ++i)
{
var a = DataSourceFactory.Create(new float[] { i, i * 10, i * 100 }, new int[] { 3, 1, 1 });
dss = new DataSourceSet();
dss.Add("a", a);
MsgPackSerializer.Serialize(dss, stream);
}
}
var total = MsgPackTools.GetTotalSampleCount(file);
Assert.AreEqual(NUM_SAMPLES, total);
var reader = MsgPackTools.ReadDataSourceSet(file, total, 4).GetEnumerator();
var hasNext = reader.MoveNext();
Assert.AreEqual(true, hasNext);
dss = reader.Current;
Assert.AreEqual(4, dss.SampleCount);
CollectionAssert.AreEqual(new int[] { 3, 1, 4 }, dss["a"].Shape.Dimensions);
CollectionAssert.AreEqual(new float[] { 0, 0, 0, 1, 10, 100, 2, 20, 200, 3, 30, 300 }, dss["a"].Data.ToArray());
hasNext = reader.MoveNext();
Assert.AreEqual(true, hasNext);
dss = reader.Current;
Assert.AreEqual(4, dss.SampleCount);
CollectionAssert.AreEqual(new int[] { 3, 1, 4 }, dss["a"].Shape.Dimensions);
CollectionAssert.AreEqual(new float[] { 4, 40, 400, 5, 50, 500, 6, 60, 600, 7, 70, 700 }, dss["a"].Data.ToArray());
hasNext = reader.MoveNext();
Assert.AreEqual(true, hasNext);
dss = reader.Current;
Assert.AreEqual(2, dss.SampleCount);
CollectionAssert.AreEqual(new int[] { 3, 1, 2 }, dss["a"].Shape.Dimensions);
CollectionAssert.AreEqual(new float[] { 8, 80, 800, 9, 90, 900 }, dss["a"].Data.ToArray());
hasNext = reader.MoveNext();
Assert.AreEqual(false, hasNext);
}
public void InterfaceInheritance(ContextFixtureBase fixture)
{
IMegaImageInfo expected = new MegaImageInfo
{
Credits = Guid.NewGuid().ToString("N"),
Height = 123,
Link = Guid.NewGuid().ToString("N"),
SomeDate = DateTime.UtcNow,
Width = 345
};
var actual = MsgPackSerializer.Deserialize <IMegaImageInfo>(MsgPackSerializer.Serialize(expected, fixture.OldContext), fixture.NewContext);
actual.ShouldBeAssignableTo <IMegaImageInfo>();
AssertEqual(actual, expected);
}
public void TestTimeSpan()
{
var tests = new List <KeyValuePair <System.TimeSpan, byte[]> >()
{
new KeyValuePair <TimeSpan, byte[]>(TimeSpan.MinValue, new byte[] { 211, 128, 0, 0, 0, 0, 0, 0, 0, }),
new KeyValuePair <TimeSpan, byte[]>(TimeSpan.MaxValue, new byte[] { 207, 127, 255, 255, 255, 255, 255, 255, 255 }),
new KeyValuePair <TimeSpan, byte[]>(new TimeSpan(1, 2, 3, 4, 5), new byte[] { 207, 0, 0, 0, 218, 91, 159, 127, 80 }),
new KeyValuePair <TimeSpan, byte[]>(TimeSpan.FromTicks(-100), new byte[] { 208, 156 }),
};
foreach (var test in tests)
{
MsgPackSerializer.Serialize(test.Key).ShouldBe(test.Value);
((MsgPackToken)test.Key).RawBytes.ShouldBe(test.Value);
}
}
public void TestDateTime()
{
var tests = new List <KeyValuePair <System.DateTime, byte[]> >()
{
new KeyValuePair <DateTime, byte[]>(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc), new byte[] { 211, 247, 96, 128, 10, 8, 74, 128, 0, }),
new KeyValuePair <DateTime, byte[]>(new DateTime(9999, 12, 31, 23, 59, 59, 999, DateTimeKind.Utc), new byte[] { 207, 35, 42, 168, 127, 252, 129, 152, 240, }),
new KeyValuePair <DateTime, byte[]>(new DateTime(2015, 11, 17, 0, 0, 0, 0, DateTimeKind.Utc), new byte[] { 207, 0, 51, 110, 236, 17, 171, 0, 0, }),
new KeyValuePair <DateTime, byte[]>(new DateTime(1, 2, 3, 4, 5, 6, DateTimeKind.Utc), new byte[] { 211, 247, 96, 154, 26, 189, 97, 197, 0, }),
};
foreach (var test in tests)
{
MsgPackSerializer.Serialize(test.Key).ShouldBe(test.Value);
((MsgPackToken)test.Key).RawBytes.ShouldBe(test.Value);
}
}
public Task <SceneEndpoint> GetSceneEndpoint <T>(string accountId, string applicationName, string sceneId, T userData)
{
var serializer = new MsgPackSerializer();
byte[] data;
using (var s = new MemoryStream())
{
serializer.Serialize(userData, s);
data = s.ToArray();
}
var logger = _resolver.Resolve <ILogger>();
logger.Log(Stormancer.Diagnostics.LogLevel.Trace, "Client", "creating endpoint request for remote server");
return(SendWithRetry(() => CreateRequest(accountId, applicationName, sceneId, data, logger), 5000, 15000).ContinueWith(t =>
{
logger.Log(Stormancer.Diagnostics.LogLevel.Trace, "Client", "Received endpoint response from remote server");
try
{
var response = t.Result;
try
{
response.EnsureSuccessStatusCode();
}
catch (HTTPException exception)
{
logger.Log(Stormancer.Diagnostics.LogLevel.Error, "Client", "GetScene failed.");
if (exception.StatusCode == HttpStatusCode.NotFound)
{
logger.Log(Stormancer.Diagnostics.LogLevel.Error, "Client", "GetScene failed: Unable to get the scene. Please check you entered the correct account id, application name and scene id.");
throw new ArgumentException("Unable to get the scene {0}/{1}/{2}. Please check you entered the correct account id, application name and scene id.", exception);
}
throw;
}
logger.Log(Stormancer.Diagnostics.LogLevel.Trace, "Client", "Token succefully received");
return _resolver.Resolve <ITokenHandler>().DecodeToken(response.ReadAsString());
}
catch (Exception ex)
{
UnityEngine.Debug.LogException(ex);
logger.Log(Stormancer.Diagnostics.LogLevel.Error, "Client", "GetScene failed: cannot retreive the connection token.");
throw new InvalidOperationException("An error occured while retrieving the connection token. See the inner exception for more informations.", ex);
}
}));
}
public void TestMsgPackSamplerSlicing2()
{
const int NUM_SAMPLES = 300;
var file = Path.GetTempFileName();
using (var stream = new FileStream(file, FileMode.Create, FileAccess.Write))
{
for (var i = 0; i < NUM_SAMPLES; ++i)
{
var a = DataSourceFactory.Create(new float[] { i, i, i }, new int[] { 1, 1, 3 });
var dss = new DataSourceSet();
dss.Add("a", a);
MsgPackSerializer.Serialize(dss, stream);
}
}
using (var sampler = new MsgPackSampler(file, 5, false, 7, 10, false, 100))
{
int count = 0;
for (var i = 0; i < 10; ++i)
{
for (var j = 0; j < NUM_SAMPLES * 3 / 5; ++j)
{
var batch = sampler.GetNextMinibatch();
Assert.AreEqual(1, batch.Features.Count);
Assert.IsTrue(batch.Features.ContainsKey("a"));
var value = batch["a"];
CollectionAssert.AreEqual(new int[] { 1, 1, 5 }, value.Shape.Dimensions.ToArray());
var ds = DataSourceFactory.FromValue(value).ToArray();
Debug.WriteLine(string.Join(", ", ds));
CollectionAssert.AreEqual(new float[]
{
j * 5 / 3,
(j * 5 + 1) / 3,
(j * 5 + 2) / 3,
(j * 5 + 3) / 3,
(j * 5 + 4) / 3
}, ds);
count += 5;
}
}
}
}
public void TestMsgPackSamplerRandomize()
{
const int NUM_CHUNKS = 30;
const int CHUNK_SIZE = 6;
const int MINIBATCH_SIZE = 2;
var data = new float[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
int FEATURE_DIM = data.Length / CHUNK_SIZE;
var file = Path.GetTempFileName();
using (var stream = new FileStream(file, FileMode.Create, FileAccess.Write))
{
for (var i = 0; i < NUM_CHUNKS; ++i)
{
var a = DataSourceFactory.Create(data, new int[] { FEATURE_DIM, CHUNK_SIZE });
var dss = new DataSourceSet();
dss.Add("a", a);
MsgPackSerializer.Serialize(dss, stream);
}
}
using (var sampler = new MsgPackSampler(file, MINIBATCH_SIZE, true, 10, 100, false, 100))
{
for (var i = 0; i < NUM_CHUNKS; ++i)
{
var values = new float[data.Length];
for (var j = 0; j < data.Length; j += FEATURE_DIM * MINIBATCH_SIZE)
{
var batch = sampler.GetNextMinibatch();
var value = DataSourceFactory.FromValue(batch["a"]);
CollectionAssert.AreEqual(new int[] { FEATURE_DIM, MINIBATCH_SIZE }, value.Shape.Dimensions.ToArray());
for (var k = 0; k < FEATURE_DIM * MINIBATCH_SIZE; ++k)
{
values[j + k] = value[k];
}
}
CollectionAssert.AreNotEqual(data, values);
var sorted = values.ToList();
sorted.Sort();
CollectionAssert.AreEqual(data, sorted);
}
}
}
public void small_test()
{
MyClass message = new MyClass()
{
Name = "TestMessage",
Quantity = 35,
Anything = new List <object>(new object[] { "First", 2, false, null, 5.5d, "last" })
};
// Serialize
byte[] buffer = MsgPackSerializer.Serialize(message);
// Deserialize
MyClass creceiveMessage = MsgPackSerializer.Deserialize <MyClass>(buffer);
Assert.AreEqual(message.Name, creceiveMessage.Name);
Assert.AreEqual(message.Quantity, creceiveMessage.Quantity);
Assert.AreEqual(message.Anything, creceiveMessage.Anything);
}
public void TestDateTimeOffset()
{
var tests = new List <KeyValuePair <System.DateTimeOffset, byte[]> >()
{
new KeyValuePair <DateTimeOffset, byte[]>(DateTimeOffset.MinValue, new byte[] { 211, 247, 96, 128, 10, 8, 74, 128, 0, }),
new KeyValuePair <DateTimeOffset, byte[]>(DateTimeOffset.MaxValue, new byte[] { 207, 35, 42, 168, 127, 252, 129, 191, 255, }),
new KeyValuePair <DateTimeOffset, byte[]>(new DateTimeOffset(2015, 11, 17, 0, 0, 0, TimeSpan.Zero), new byte[] { 207, 0, 51, 110, 236, 17, 171, 0, 0, }),
new KeyValuePair <DateTimeOffset, byte[]>(new DateTimeOffset(1, 2, 3, 4, 5, 6, TimeSpan.Zero), new byte[] { 211, 247, 96, 154, 26, 189, 97, 197, 0, }),
new KeyValuePair <DateTimeOffset, byte[]>(new DateTimeOffset(1, 2, 3, 4, 5, 6, TimeSpan.FromHours(12)), new byte[] { 211, 247, 96, 153, 182, 40, 44, 229, 0, }),
new KeyValuePair <DateTimeOffset, byte[]>(new DateTimeOffset(1, 2, 3, 4, 5, 6, TimeSpan.FromMinutes(361)), new byte[] { 211, 247, 96, 153, 232, 79, 4, 15, 0, }),
};
foreach (var test in tests)
{
MsgPackSerializer.Serialize(test.Key).ShouldBe(test.Value);
((MsgPackToken)test.Key).RawBytes.ShouldBe(test.Value);
}
}
private async Task <MemoryStream> SendRequestImpl <TRequest>(TRequest request, TimeSpan?timeout)
where TRequest : IRequest
{
if (_disposed)
{
throw new ObjectDisposedException(nameof(LogicalConnection));
}
var bodyBuffer = MsgPackSerializer.Serialize(request, _msgPackContext);
var requestId = _requestIdCounter.GetRequestId();
var responseTask = _responseReader.GetResponseTask(requestId);
var headerBuffer = CreateAndSerializeHeader(request, requestId, bodyBuffer);
_requestWriter.Write(
headerBuffer,
new ArraySegment <byte>(bodyBuffer, 0, bodyBuffer.Length));
try
{
if (timeout.HasValue)
{
var cts = new CancellationTokenSource(timeout.Value);
responseTask = responseTask.WithCancellation(cts.Token);
}
var responseStream = await responseTask.ConfigureAwait(false);
_logWriter?.WriteLine($"Response with requestId {requestId} is recieved, length: {responseStream.Length}.");
return(responseStream);
}
catch (ArgumentException)
{
_logWriter?.WriteLine($"Response with requestId {requestId} failed, header:\n{headerBuffer.ToReadableString()} \n body: \n{bodyBuffer.ToReadableString()}");
throw;
}
catch (TimeoutException)
{
PingsFailedByTimeoutCount++;
throw;
}
}
public void SmokeSerialization()
{
var oldContext = new MsgPackContext();
oldContext.RegisterConverter(new InnerClassConverter());
var newContext = new MsgPackContext();
newContext.DiscoverConverters <InnerClass>();
var s = Guid.NewGuid().ToString("B");
var expected = new InnerClass {
B = s
};
MsgPackSerializer.Serialize(expected, newContext).ShouldBe(MsgPackSerializer.Serialize(expected, oldContext));
MsgPackSerializer.Deserialize <InnerClass>(MsgPackSerializer.Serialize(expected, oldContext), newContext).B.ShouldBe(s);
MsgPackSerializer.Deserialize <InnerClass>(MsgPackSerializer.Serialize(expected, newContext), oldContext).B.ShouldBe(s);
}
private ArraySegment <byte> CreateAndSerializeHeader <TRequest>(
TRequest request,
RequestId requestId,
byte[] serializedRequest) where TRequest : IRequest
{
var packetSizeBuffer = new byte[Constants.PacketSizeBufferSize + Constants.MaxHeaderLength];
var stream = new MemoryStream(packetSizeBuffer);
var requestHeader = new RequestHeader(request.Code, requestId);
stream.Seek(Constants.PacketSizeBufferSize, SeekOrigin.Begin);
MsgPackSerializer.Serialize(requestHeader, stream, _msgPackContext);
var lengthAndHeaderLengthByteCount = (int)stream.Position;
var headerLength = lengthAndHeaderLengthByteCount - Constants.PacketSizeBufferSize;
var packetLength = new PacketSize((uint)(headerLength + serializedRequest.Length));
stream.Seek(0, SeekOrigin.Begin);
MsgPackSerializer.Serialize(packetLength, stream, _msgPackContext);
return(new ArraySegment <byte>(packetSizeBuffer, 0, lengthAndHeaderLengthByteCount));
}
public void TestMsgPackSampler()
{
const int NUM_SAMPLES = 1000;
var file = Path.GetTempFileName();
using (var stream = new FileStream(file, FileMode.Create, FileAccess.Write))
{
for (var i = 0; i < NUM_SAMPLES; ++i)
{
var a = DataSourceFactory.Create(new float[] { i, i * 10, i * 100 }, new int[] { 3, 1, 1 });
var dss = new DataSourceSet();
dss.Add("a", a);
MsgPackSerializer.Serialize(dss, stream);
}
}
using (var sampler = new MsgPackSampler(file, 1, false, 3, 10, false, 100))
{
for (var i = 0; i < 10; ++i)
{
for (var j = 0; j < NUM_SAMPLES; ++j)
{
var batch = sampler.GetNextMinibatch();
Assert.AreEqual(1, batch.Features.Count);
Assert.IsTrue(batch.Features.ContainsKey("a"));
Assert.AreEqual((i * NUM_SAMPLES + j + 1) % 3 == 0, batch.SweepEnd);
var value = batch["a"];
CollectionAssert.AreEqual(new int[] { 3, 1, 1 }, value.Shape.Dimensions.ToArray());
var ds = DataSourceFactory.FromValue(value).ToArray();
// Debug.WriteLine(string.Join(", ", ds));
CollectionAssert.AreEqual(new float[] { j, j * 10, j * 100 }, ds);
}
}
}
}
public void TestMsgPackSamplerSampleCountPerEpoch()
{
const int NUM_SAMPLES = 3;
const int NUM_CHUNKS = 100;
var file = Path.GetTempFileName();
using (var stream = new FileStream(file, FileMode.Create, FileAccess.Write))
{
for (var i = 0; i < NUM_CHUNKS; ++i)
{
var a = DataSourceFactory.Create(new float[] { i, i * 10, i * 100 }, new int[] { 1, 1, NUM_SAMPLES });
var dss = new DataSourceSet();
dss.Add("a", a);
MsgPackSerializer.Serialize(dss, stream);
}
}
using (var sampler = new MsgPackSampler(file, 1, false, -1, 10, false, 100))
{
Assert.AreEqual(NUM_SAMPLES * NUM_CHUNKS, sampler.SampleCountPerEpoch);
}
}
public void TestMsgPackSamplerReuseSamples()
{
var file = Path.GetTempFileName();
using (var stream = new FileStream(file, FileMode.Create, FileAccess.Write))
{
for (var i = 0; i < 1000; ++i)
{
var a = DataSourceFactory.Create(new float[] { i, i * 10, i * 100 }, new int[] { 3, 1, 1 });
var dss = new DataSourceSet();
dss.Add("a", a);
MsgPackSerializer.Serialize(dss, stream);
}
}
using (var sampler = new MsgPackSampler(file, 1, false, 100, 100, true, 1000))
{
for (var i = 0; i < 10000; ++i)
{
var batch = sampler.GetNextMinibatch();
Assert.IsTrue(batch.Features.ContainsKey("a"));
}
}
}
public void TestArrayPack()
{
var tests = new object[]
{
0,
50505,
float.NaN,
float.MaxValue,
new[] { true, false, true },
null,
new Dictionary <string, string> {
{ "Ball", "Soccer" }
}
};
var data = new byte[]
{
151,
0,
205, 197, 73,
202, 255, 192, 0, 0,
202, 127, 127, 255, 255,
147,
195,
194,
195,
192,
129,
164, 66, 97, 108, 108, 166, 83, 111, 99, 99, 101, 114
};
var settings = new MsgPackContext();
settings.RegisterConverter(new TestReflectionConverter());
MsgPackSerializer.Serialize(tests, settings).ShouldBe(data);
}
public void False()
{
MsgPackSerializer.Serialize((bool?)false).ShouldBe(new[] { (byte)DataTypes.False });
((MsgPackToken)(bool?)false).RawBytes.ShouldBe(new[] { (byte)DataTypes.False });
}
public void CreatAuthPacket()
{
var greetings = Encoding.UTF8.GetBytes("Tarantool 1.6.8 (Binary) e8a5ec82-2fd5-4798-aafa-ac41acabc727 DCHe8DF5IQKb8ZphIRjOxQlMiLjooLtazaUh+SPzXi0=");
var uriBuilder = new UriBuilder
{
Password = "******",
UserName = "******"
};
var packet = AuthenticationRequest.Create(new GreetingsResponse(greetings), uriBuilder);
var msgPackContext = new MsgPackContext();
TarantoolConvertersRegistrator.Register(msgPackContext);
var serialzied = MsgPackSerializer.Serialize(packet, msgPackContext);
var expected = new byte[]
{
0x82,
0x23,
0xa4,
0x74,
0x65,
0x73,
0x74,
0x21,
0x92,
0xa9,
0x63,
0x68,
0x61,
0x70,
0x2d,
0x73,
0x68,
0x61,
0x31,
0xc4,
0x14,
0xd4,
0xe2,
0x10,
0x62,
0x8a,
0xa8,
0xba,
0xb3,
0xa5,
0x25,
0xb0,
0x02,
0x72,
0xd9,
0x13,
0xd7,
0x4f,
0x64,
0x9d,
0x0c,
};
serialzied.ShouldBe(expected);
}
public void WriteNullString()
{
MsgPackSerializer.Serialize((string)null).ShouldBe(new[] { (byte)DataTypes.Null });
((MsgPackToken)(string)null).RawBytes.ShouldBe(new[] { (byte)DataTypes.Null });
}
public void True()
{
MsgPackSerializer.Serialize((bool?)true).ShouldBe(new[] { (byte)DataTypes.True });
((MsgPackToken)(bool?)true).RawBytes.ShouldBe(new[] { (byte)DataTypes.True });
}
public void WriteNullMap()
{
MsgPackSerializer.Serialize((IDictionary <int, int>)null).ShouldBe(new[] { (byte)DataTypes.Null });
}
public void WriteNullByteArray()
{
MsgPackSerializer.Serialize((byte[])null).ShouldBe(new[] { (byte)DataTypes.Null });
((MsgPackToken)(byte[])null).RawBytes.ShouldBe(new[] { (byte)DataTypes.Null });
}
public void WriteNullArray()
{
MsgPackSerializer.Serialize((int[])null).ShouldBe(new[] { (byte)DataTypes.Null });
}
public void MPLight_Array_AutoArray()
{
var bytes = MsgPackSerializer.Serialize(_testBeer, Serializers.MsgPackLightArrayAutoGeneration);
}
public void MPLight_Array()
{
var bytes = MsgPackSerializer.Serialize(_testBeer, Serializers.MsgPackLight);
}
