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)); }