public void Receiving_packet_should_be_properly_deserialized()
            {
                var received   = false;
                var serializer = new ProtoBufStacksSerializer();
                var packet     = new MemoryStream();

                serializer.Serialize(CreateSampleTestData(), packet);

                var client = new ReactiveMessageClient <ITestMessageHandler>(framedClient, serializer);

                client.Packets.TestPackets.Subscribe(p =>
                {
                    Assert.Equal(42, p.Foo);
                    Assert.Equal(Math.PI, p.Bar);
                    Assert.Equal((decimal)Math.PI, p.Zar);
                    Assert.Equal("Foo bar test", p.Sar);
                    received = true;
                });


                rawClientReceived.OnNext(new ArraySegment <byte>(BitConverter.GetBytes((int)packet.Length + 8)));
                rawClientReceived.OnNext(new ArraySegment <byte>(BitConverter.GetBytes(3)));
                rawClientReceived.OnNext(new ArraySegment <byte>(packet.GetBuffer(), 0, (int)packet.Length));

                Assert.True(received);
            }
            public void When_more_packets_are_registered_only_valid_observer_should_be_notified()
            {
                var validReceived   = false;
                var invalidReceived = false;
                var serializer      = new ProtoBufStacksSerializer();
                var packet          = new MemoryStream();

                serializer.Serialize(new TestData2 {
                    Bar = 6
                }, packet);

                var client = new ReactiveMessageClient <IComplexTestMessageHandler>(framedClient, serializer);

                client.Packets.TestPackets.Subscribe(p =>
                {
                    invalidReceived = true;
                });
                client.Packets.TestPackets2.Subscribe(p =>
                {
                    validReceived = true;
                });


                rawClientReceived.OnNext(new ArraySegment <byte>(BitConverter.GetBytes((int)packet.Length + 8)));
                rawClientReceived.OnNext(new ArraySegment <byte>(BitConverter.GetBytes(1)));
                rawClientReceived.OnNext(new ArraySegment <byte>(packet.GetBuffer(), 0, (int)packet.Length));

                Assert.True(validReceived);
                Assert.False(invalidReceived);
            }
Ejemplo n.º 3
0
            public void Deserialize_object_properly()
            {
                var test = CreateSampleTestData();
                var obj  = CreateSerializedObject(test);

                Console.WriteLine(new ArraySegment <byte>(obj.GetBuffer(), 0, (int)obj.Length).ToBinaryString());

                var serializer = new ProtoBufStacksSerializer();
                var data       = serializer.Deserialize <TestData>(obj);

                Assert.Equal(test.Bar, data.Bar);
                Assert.Equal(test.Foo, data.Foo);
                Assert.Equal(test.Sar, data.Sar);
                Assert.Equal(test.Zar, data.Zar);
            }
Ejemplo n.º 4
0
            public void Serialize_data_so_it_can_be_later_deserialized_with_Deserialize()
            {
                var test = CreateSampleTestData();

                var serializer = new ProtoBufStacksSerializer();
                var ms         = new MemoryStream();

                serializer.Serialize(test, ms);
                ms.Position = 0;
                var data = serializer.Deserialize <TestData>(ms);

                Assert.Equal(test.Bar, data.Bar);
                Assert.Equal(test.Foo, data.Foo);
                Assert.Equal(test.Sar, data.Sar);
                Assert.Equal(test.Zar, data.Zar);
            }
Ejemplo n.º 5
0
            public void When_more_packets_are_registered_only_valid_observer_should_be_notified()
            {
                var validReceived = false;
                var invalidReceived = false;
                var serializer = new ProtoBufStacksSerializer();
                var packet = new MemoryStream();
                serializer.Serialize(new TestData2 { Bar = 6 }, packet);

                var client = new ReactiveMessageClient<IComplexTestMessageHandler>(framedClient, serializer);
                client.Packets.TestPackets.Subscribe(p =>
                {
                    invalidReceived = true;
                });
                client.Packets.TestPackets2.Subscribe(p =>
                {
                    validReceived = true;
                });

                rawClientReceived.OnNext(new ArraySegment<byte>(BitConverter.GetBytes((int)packet.Length + 8)));
                rawClientReceived.OnNext(new ArraySegment<byte>(BitConverter.GetBytes(1)));
                rawClientReceived.OnNext(new ArraySegment<byte>(packet.GetBuffer(), 0, (int)packet.Length));

                Assert.True(validReceived);
                Assert.False(invalidReceived);
            }
Ejemplo n.º 6
0
            public void Receiving_packet_should_be_properly_deserialized()
            {
                var received = false;
                var serializer = new ProtoBufStacksSerializer();
                var packet = new MemoryStream();
                serializer.Serialize(CreateSampleTestData(), packet);

                var client = new ReactiveMessageClient<ITestMessageHandler>(framedClient, serializer);
                client.Packets.TestPackets.Subscribe(p =>
                    {
                        Assert.Equal(42, p.Foo);
                        Assert.Equal(Math.PI, p.Bar);
                        Assert.Equal((decimal)Math.PI, p.Zar);
                        Assert.Equal("Foo bar test", p.Sar);
                        received = true;
                    });

                rawClientReceived.OnNext(new ArraySegment<byte>(BitConverter.GetBytes((int)packet.Length + 8)));
                rawClientReceived.OnNext(new ArraySegment<byte>(BitConverter.GetBytes(3)));
                rawClientReceived.OnNext(new ArraySegment<byte>(packet.GetBuffer(), 0, (int)packet.Length));

                Assert.True(received);
            }