public async Task <DataResponse> SendRequest <TRequest>(TRequest request, TimeSpan?timeout = null)
where TRequest : IRequest
{
var stream = await SendRequestImpl(request, timeout).ConfigureAwait(false);
return(MsgPackSerializer.Deserialize <DataResponse>(stream, _msgPackContext));
}
public void WriteFlagEnumAsString(FlagEnum enumValue)
{
var enumAsStringResult = MsgPackSerializer.Serialize(enumValue);
var enumAsStringExpected = MsgPackSerializer.Serialize(enumValue.ToString());
enumAsStringResult.ShouldBe(enumAsStringExpected);
}
public void SimpleArray()
{
var tests = new[]
{
"a",
"b",
"c",
"d",
"e"
};
var bytes = new byte[]
{
149,
161, 97,
161, 98,
161, 99,
161, 100,
161, 101
};
MsgPackSerializer.Serialize(tests).ShouldBe(bytes);
new MsgPackToken(tests.Select(e => (MsgPackToken)e).ToArray()).RawBytes.ShouldBe(bytes);
}
public void TestMsgPackSamplerMultipleFiles()
{
var files = new string[2];
for (var i = 0; i < 2; ++i)
{
files[i] = Path.GetTempFileName();
var a = DataSourceFactory.Create(new float[] { i, i + 1, i + 2 }, new int[] { 3, 1 });
var dss = new DataSourceSet();
dss.Add("a", a);
using (var stream = new FileStream(files[i], FileMode.Create, FileAccess.Write))
{
MsgPackSerializer.Serialize(dss, stream);
}
}
using (var sampler = new MsgPackSampler(files, 3, false, -1, 10, false, 10))
{
Assert.AreEqual(2, sampler.SampleCountPerEpoch);
var batch = sampler.GetNextMinibatch();
CollectionAssert.AreEqual(new int[] { 3, 3 }, batch.Features["a"].Shape.Dimensions.ToArray());
var values = DataSourceFactory.FromValue(batch.Features["a"]);
CollectionAssert.AreEqual(new float[] { 0, 1, 2, 1, 2, 3, 0, 1, 2 }, values.TypedData);
}
}
private void MatchResult(byte[] result)
{
var resultStream = new MemoryStream(result);
var header = MsgPackSerializer.Deserialize <ResponseHeader>(resultStream, _clientOptions.MsgPackContext);
var tcs = PopResponseCompletionSource(header.RequestId);
if (tcs == null)
{
if (_clientOptions.LogWriter != null)
{
LogUnMatchedResponse(result, _clientOptions.LogWriter);
}
return;
}
if ((header.Code & CommandCode.ErrorMask) == CommandCode.ErrorMask)
{
var errorResponse = MsgPackSerializer.Deserialize <ErrorResponse>(resultStream, _clientOptions.MsgPackContext);
tcs.SetException(ExceptionHelper.TarantoolError(header, errorResponse));
}
else
{
_clientOptions.LogWriter?.WriteLine($"Match for request with id {header.RequestId} found.");
Task.Run(() => tcs.SetResult(resultStream));
}
}
private void TestGenericList <T> (T entry1, T entry2)
{
List <T> objList = new List <T>();
objList.Add(entry1);
objList.Add(entry2);
string logHeader = string.Format("List<{0}>: ", typeof(T).ToString());
var msg = MsgPackSerializer.SerializeObject(objList);
var desizList = MsgPackSerializer.Deserialize <List <T> >(msg);
Assert.That(desizList != null, logHeader + "null desiz");
Assert.That(typeof(List <T>) == desizList.GetType(), logHeader + "different types");
if (entry1 == null)
{
Assert.That(objList[0] == null);
}
else
{
Assert.That(desizList[0].Equals(entry1), logHeader + "value lost 1: " + entry1.ToString());
}
if (entry2 == null)
{
Assert.That(objList[1] == null);
}
else
{
Assert.That(desizList[1].Equals(entry2), logHeader + "value lost 2: " + entry2.ToString());
}
}
public void SimpleDictionary()
{
var test = new Dictionary <int, string>
{
{ 1, "a" },
{ 2, "b" },
{ 3, "c" },
{ 4, "d" },
{ 5, "e" }
};
var bytes = new byte[]
{
133,
1, 161, 97,
2, 161, 98,
3, 161, 99,
4, 161, 100,
5, 161, 101
};
MsgPackSerializer.Deserialize <Dictionary <int, string> >(bytes).ShouldBe(test);
var token = Helpers.CheckTokenDeserialization(bytes);
((Dictionary <MsgPackToken, MsgPackToken>)token)
.ToDictionary(kvp => (int)kvp.Key, kvp => (string)kvp.Value)
.ShouldBe(test);
}
public void WriteOldBinary(byte[] value, byte[] data)
{
var context = new MsgPackContext(binaryCompatibilityMode: true);
var result = Should.NotThrow(() => MsgPackSerializer.Serialize(value, context));
result.ShouldBe(data);
}
public void TestMultipleObjects()
{
var a = DataSourceFactory.Create(new float[] { 1, 2, 3 }, new int[] { 3, 1, 1 });
var dss = new DataSourceSet();
dss.Add("a", a);
var dss2 = new DataSourceSet();
var b = DataSourceFactory.Create(new float[] { 4, 5, 6, 7 }, new int[] { 2, 2, 1 });
dss2.Add("b", b);
var stream = new MemoryStream();
MsgPackSerializer.Serialize(dss, stream);
MsgPackSerializer.Serialize(dss2, stream);
stream.Position = 0;
var result = MsgPackSerializer.Deserialize(stream);
var result2 = MsgPackSerializer.Deserialize(stream);
Assert.AreEqual(1, result.Features.Count);
var x = result["a"];
CollectionAssert.AreEqual(new int[] { 3, 1, 1 }, x.Shape.Dimensions);
CollectionAssert.AreEqual(new float[] { 1, 2, 3 }, x.Data.ToArray());
Assert.AreEqual(1, result2.Features.Count);
var y = result2["b"];
CollectionAssert.AreEqual(new int[] { 2, 2, 1 }, y.Shape.Dimensions);
CollectionAssert.AreEqual(new float[] { 4, 5, 6, 7 }, y.Data.ToArray());
}
public void TestEventDtos()
{
var dto = new GameEventsGetResponse();
dto.Marquees = new List <GameMarquee>();
dto.Events = new List <GameEvent>();
dto.Events.Add(new GameEvent()
{
Id = 66,
Order = 0,
StartTime = DateTime.Now.Subtract(new TimeSpan(1, 0, 0)),
EndTime = DateTime.Now.Add(new TimeSpan(1, 0, 0)),
Icon = "https://s3.amazonaws.com/dev-withbuddies-event-lobby/41d62a1b-7926-4754-84c8-0c6c91da401c",
Title = "Amber Special Event",
Subtitle = "Testing 4.17 features"
});
dto.Version = "2";
MsgPackSerializer.DefaultContext.RegisterSerializer <GameEventsGetResponse>("Events", "Marquees", "Version");
MsgPackSerializer.DefaultContext.RegisterSerializer <GameEvent>("Id", "Order", "StartTime", "EndTime", "Icon", "Title", "Subtitle");
byte[] payload = dto.ToMsgPack();
Assert.IsNotNull(payload);
Assert.AreNotEqual(0, payload.Length);
var restoredDto = MsgPackSerializer.Deserialize <GameEventsGetResponse>(payload);
Assert.IsNotNull(restoredDto);
Assert.AreEqual("2", restoredDto.Version);
Assert.IsNotNull(restoredDto.Events);
Assert.AreEqual(1, restoredDto.Events.Count);
Assert.AreEqual(dto.Events[0].Id, restoredDto.Events[0].Id);
Assert.AreEqual(dto.Events[0].Order, restoredDto.Events[0].Order);
Assert.AreEqual(dto.Events[0].Icon, restoredDto.Events[0].Icon);
Assert.AreEqual(dto.Events[0].Title, restoredDto.Events[0].Title);
Assert.AreEqual(dto.Events[0].Subtitle, restoredDto.Events[0].Subtitle);
}
public void TestDateTimeOffset()
{
var tests = new List <KeyValuePair <byte[], System.DateTimeOffset> >()
{
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 211, 247, 96, 128, 10, 8, 74, 128, 0, }, DateTimeOffset.MinValue),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 211, 35, 42, 168, 127, 252, 129, 191, 255, }, DateTimeOffset.MaxValue),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 211, 0, 51, 110, 236, 17, 171, 0, 0, }, new DateTimeOffset(2015, 11, 17, 0, 0, 0, TimeSpan.Zero)),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 211, 247, 96, 154, 26, 189, 97, 197, 0, }, new DateTimeOffset(1, 2, 3, 4, 5, 6, TimeSpan.Zero)),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 211, 247, 96, 153, 182, 40, 44, 229, 0, }, new DateTimeOffset(1, 2, 3, 4, 5, 6, TimeSpan.FromHours(12))),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 211, 247, 96, 153, 232, 79, 4, 15, 0, }, new DateTimeOffset(1, 2, 3, 4, 5, 6, TimeSpan.FromMinutes(361))),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 207, 247, 96, 128, 10, 8, 74, 128, 0, }, DateTimeOffset.MinValue),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 207, 35, 42, 168, 127, 252, 129, 191, 255, }, DateTimeOffset.MaxValue),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 207, 0, 51, 110, 236, 17, 171, 0, 0, }, new DateTimeOffset(2015, 11, 17, 0, 0, 0, TimeSpan.Zero)),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 207, 247, 96, 154, 26, 189, 97, 197, 0, }, new DateTimeOffset(1, 2, 3, 4, 5, 6, TimeSpan.Zero)),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 207, 247, 96, 153, 182, 40, 44, 229, 0, }, new DateTimeOffset(1, 2, 3, 4, 5, 6, TimeSpan.FromHours(12))),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 207, 247, 96, 153, 232, 79, 4, 15, 0, }, new DateTimeOffset(1, 2, 3, 4, 5, 6, TimeSpan.FromMinutes(361))),
};
foreach (var test in tests)
{
MsgPackSerializer.Deserialize <System.DateTimeOffset>(test.Key).ShouldBe(test.Value);
var token = Helpers.CheckTokenDeserialization(test.Key);
((DateTimeOffset)token).ShouldBe(test.Value);
}
}
public void ReadFlagEnumAsString(FlagEnum enumValue)
{
var bytes = MsgPackSerializer.Serialize(enumValue.ToString());
var enumResult = MsgPackSerializer.Deserialize <FlagEnum>(bytes);
enumResult.ShouldBe(enumValue);
}
public Serialization()
{
_json = new JsonSerializer();
_msgpack = new MsgPackSerializer();
var random = new Random();
var byteBuffer = new byte[50000000];
random.NextBytes(byteBuffer);
_serializeObject = new JObject
{
new JProperty("responses", new JArray
{
new JObject
{
new JProperty("updates", new JArray
{
new JArray
{
byteBuffer
}
})
}
})
};
}
private MemoryStream PrepareMsgPack <T>(T item)
{
var memoryStream = new MemoryStream();
MsgPackSerializer.Serialize(item, memoryStream, Serializers.MsgPackLight);
return(memoryStream);
}
public void SimpleDictionary()
{
var test = new Dictionary <int, string>
{
{ 1, "a" },
{ 2, "b" },
{ 3, "c" },
{ 4, "d" },
{ 5, "e" }
};
var bytes = new byte[]
{
133,
1, 161, 97,
2, 161, 98,
3, 161, 99,
4, 161, 100,
5, 161, 101
};
MsgPackSerializer.Serialize(test).ShouldBe(bytes);
new MsgPackToken(test.ToDictionary(e => (MsgPackToken)e.Key, e => (MsgPackToken)e.Value)).RawBytes.ShouldBe(bytes);
}
public void TestNonFixedArray()
{
var array = new[]
{
1, 2, 3, 4, 5,
1, 2, 3, 4, 5,
1, 2, 3, 4, 5,
1, 2, 3, 4, 5,
};
var bytes = new byte[]
{
0xdc,
0x00,
0x14,
0x01, 0x02, 0x03, 0x04, 0x05,
0x01, 0x02, 0x03, 0x04, 0x05,
0x01, 0x02, 0x03, 0x04, 0x05,
0x01, 0x02, 0x03, 0x04, 0x05,
};
MsgPackSerializer.Deserialize <int[]>(bytes).ShouldBe(array);
var token = Helpers.CheckTokenDeserialization(bytes);
((MsgPackToken[])token).Select(t => (int)t).ToArray().ShouldBe(array);
}
public void SimpleArray()
{
var tests = new[]
{
"a",
"b",
"c",
"d",
"e"
};
var bytes = new byte[]
{
149,
161, 97,
161, 98,
161, 99,
161, 100,
161, 101
};
MsgPackSerializer.Deserialize <string[]>(bytes).ShouldBe(tests);
var token = Helpers.CheckTokenDeserialization(bytes);
((MsgPackToken[])token).Select(t => (string)t).ToArray().ShouldBe(tests);
}
public static MsgPackToken CheckTokenDeserialization(byte[] data)
{
var token = MsgPackSerializer.Deserialize <MsgPackToken>(data);
token.RawBytes.ShouldBe(data);
return(token);
}
public void Test(bool value, byte[] data)
{
MsgPackSerializer.Deserialize <bool>(data).ShouldBe(value);
var token = Helpers.CheckTokenDeserialization(data);
((bool)token).ShouldBe(value);
}
public void TetsUnsignedByte(byte number, byte[] data)
{
MsgPackSerializer.Deserialize <byte?>(data).ShouldBe(number);
var token = Helpers.CheckTokenDeserialization(data);
((byte?)token).ShouldBe(number);
}
public void TestFloat(float value, byte[] bytes)
{
MsgPackSerializer.Deserialize <float>(bytes).ShouldBe(value);
var token = Helpers.CheckTokenDeserialization(bytes);
((float)token).ShouldBe(value);
}
public void TestStringPack(string s, byte[] data)
{
MsgPackSerializer.Deserialize <string>(data).ShouldBe(s);
var token = Helpers.CheckTokenDeserialization(data);
((string)token).ShouldBe(s);
}
public void ReadSmoke(ContextFixtureBase fixture)
{
IImageInfo expected = CreateTestObject();
var actual = MsgPackSerializer.Deserialize <IImageInfo>(MsgPackSerializer.Serialize(expected, fixture.NewContext), fixture.NewContext);
AssertEqual(actual, expected);
}
public void TestSignedInt(int number, byte[] data)
{
MsgPackSerializer.Deserialize <int?>(data).ShouldBe(number);
var token = Helpers.CheckTokenDeserialization(data);
((int?)token).ShouldBe(number);
}
public void WriteOldReadNew(ContextFixtureBase fixture)
{
var expected = CreateTestObject();
var actual = MsgPackSerializer.Deserialize <ImageInfo>(MsgPackSerializer.Serialize(expected, fixture.OldContext), fixture.NewContext);
AssertEqual(actual, expected);
}
public void TetsUnsignedShort(ushort number, byte[] data)
{
MsgPackSerializer.Deserialize <ushort?>(data).ShouldBe(number);
var token = Helpers.CheckTokenDeserialization(data);
((ushort?)token).ShouldBe(number);
}
public void TestDouble(double value, byte[] bytes)
{
MsgPackSerializer.Deserialize <double?>(bytes).ShouldBe(value);
var token = Helpers.CheckTokenDeserialization(bytes);
((double?)token).ShouldBe(value);
}
public void TestSignedLong(long number, byte[] data)
{
MsgPackSerializer.Deserialize <long?>(data).ShouldBe(number);
var token = Helpers.CheckTokenDeserialization(data);
((long?)token).ShouldBe(number);
}
public void ReadUintEnum(UintEnum enumValue)
{
var intEnumContext = new MsgPackContext(convertEnumsAsStrings: false);
var bytes = MsgPackSerializer.Serialize((uint)enumValue, intEnumContext);
var enumResult = MsgPackSerializer.Deserialize <UintEnum>(bytes, intEnumContext);
enumResult.ShouldBe(enumValue);
}
public static byte[] ToMsgPack(this object o)
{
if (o == null)
{
throw new ArgumentException("Can't serialize null references", "o");
}
return(MsgPackSerializer.SerializeObject(o));
}
