public void Deserialize_ThrowsExecption_IfMessageIsNothaveValidType()
        {
            var       bytes = new byte[11];
            Exception ex    = Assert.Throws <Exception>(() => CancelRequestSerializer.Deserialize(bytes));

            Assert.Equal(Types.Constant.INVALID_MESSAGE, ex.Message);
        }
        public void Deserialize_ThrowsExecption_IfMessageIsGreaterThan35Bytes()
        {
            var       bytes = new byte[16];
            Exception ex    = Assert.Throws <Exception>(() => CancelRequestSerializer.Deserialize(bytes));

            Assert.Equal("Cancel Request Message must be of Size : 15", ex.Message);
        }
        public void Deserialize_ThrowsExecption_IfMessageIsNothaveValidType()
        {
            var       bytes = new byte[15];
            Exception ex    = Assert.Throws <Exception>(() => CancelRequestSerializer.Deserialize(bytes));

            Assert.Equal("Invalid Message", ex.Message);
        }
Example #4
0
        private void OnMessage(byte[] body)
        {
            var    type = Serializer.GetMessageType(body);
            object obj  = null;

            switch (type)
            {
            case MessageType.NewOrderRequest:
                obj = OrderSerializer.Deserialize(body);
                break;

            case MessageType.CancelRequest:
                obj = CancelRequestSerializer.Deserialize(body);
                break;

            case MessageType.BookRequest:
                obj = BookRequestSerializer.Deserialize(body);
                break;

            default:
                //TODO
                break;
            }
            var message = new Message(type.Value, body, obj);

            _inboundChannelWritter.TryWrite(message);
        }
        public void Serialize_Doesnotthrowexception_Max()
        {
            Span <byte> bytes = stackalloc byte[CancelRequestSerializer.MessageSize];

            CancelRequestSerializer.Serialize(new CancelRequest {
                OrderId = OrderId.MaxValue
            }, bytes);
        }
        public void Deserialize_ThrowsExecption_IfVersionIsNotSet()
        {
            var bytes = new byte[15];

            bytes[4] = (byte)MessageType.CancelRequest;
            Exception ex = Assert.Throws <Exception>(() => CancelRequestSerializer.Deserialize(bytes));

            Assert.Equal("version mismatch", ex.Message);
        }
        public void Deserialize_ThrowsExecption_IfVersionIsNotSet()
        {
            var bytes = new byte[11];

            bytes[4] = (byte)MessageType.CancelRequest;
            Exception ex = Assert.Throws <Exception>(() => CancelRequestSerializer.Deserialize(bytes));

            Assert.Equal(Types.Constant.INVALID_VERSION, ex.Message);
        }
Example #8
0
        private void SendCancelRequest(int orderId)
        {
            var cancelRequest = new CancelRequest()
            {
                OrderId = orderId
            };
            var bytes = CancelRequestSerializer.Serialize(cancelRequest);

            _queueProducer.Produce(bytes);
        }
Example #9
0
        public void Deserialize_Doesnotthrowexception()
        {
            var bytes = CancelRequestSerializer.Serialize(new CancelRequest {
                OrderId = 12345678
            });
            var messageLength = BitConverter.ToInt32(bytes, 0);

            Assert.Equal(11, messageLength);
            var cancelRequest = CancelRequestSerializer.Deserialize(bytes);

            Assert.Equal((OrderId)12345678, cancelRequest.OrderId);
        }
        public void Deserialize_Doesnotthrowexception_Max()
        {
            var bytes = CancelRequestSerializer.Serialize(new CancelRequest {
                OrderId = ulong.MaxValue
            });
            var messageLength = BitConverter.ToInt32(bytes, 0);

            Assert.Equal(15, messageLength);
            var cancelRequest = CancelRequestSerializer.Deserialize(bytes);

            Assert.Equal(ulong.MaxValue, cancelRequest.OrderId);
        }
        public void Deserialize_Doesnotthrowexception_Min()
        {
            Span <byte> bytes = stackalloc byte[CancelRequestSerializer.MessageSize];

            CancelRequestSerializer.Serialize(new CancelRequest {
                OrderId = OrderId.MinValue
            }, bytes);
            var messageLength = BitConverter.ToInt32(bytes.Slice(0));

            Assert.Equal(11, messageLength);
            var cancelRequest = CancelRequestSerializer.Deserialize(bytes);

            Assert.Equal(OrderId.MinValue, cancelRequest.OrderId);
        }
        public void Deserialize_ThrowsExecption_IfNullPassed()
        {
            ArgumentNullException ex = Assert.Throws <ArgumentNullException>(() => CancelRequestSerializer.Deserialize(null));

            Assert.Equal("bytes", ex.ParamName);
        }
        public SerializeBenchmark()
        {
            book = new Book();
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = true, IsTip = false, OpenQuantity = 1000, OrderId = 3434, Price = 234
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = true, IsTip = false, OpenQuantity = 1000, OrderId = 3434, Price = 235
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = true, IsTip = false, OpenQuantity = 1000, OrderId = 3435, Price = 236
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = true, IsTip = false, OpenQuantity = 1000, OrderId = 3436, Price = 237
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = true, IsTip = false, OpenQuantity = 1000, OrderId = 3437, Price = 238
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = false, IsTip = false, OpenQuantity = 1000, OrderId = 3438, Price = 239
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = false, IsTip = false, OpenQuantity = 1000, OrderId = 3439, Price = 240
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = false, IsTip = false, OpenQuantity = 1000, OrderId = 3440, Price = 241
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = false, IsTip = false, OpenQuantity = 1000, OrderId = 3441, Price = 242
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = false, IsTip = false, OpenQuantity = 1000, OrderId = 3442, Price = 243
            });
            bid = book.BidSide.Select(x => new KeyValuePair <Price, Quantity>(x.Key, x.Value.Quantity)).ToList();
            ask = book.AskSide.Select(x => new KeyValuePair <Price, Quantity>(x.Key, x.Value.Quantity)).ToList();

            var order = new Order {
                CancelOn = 12345678, IsBuy = true, OrderId = 56789, Price = 404, OpenQuantity = 1000
            };
            var orderWrapper = new OrderWrapper()
            {
                Order = order, OrderCondition = OrderCondition.ImmediateOrCancel, StopPrice = 9534, TotalQuantity = 7878234
            };

            orderJsonString       = JsonConvert.SerializeObject(orderWrapper);
            orderBinarySerialized = OrderSerializer.Serialize(orderWrapper);
            orderMsgPck           = MessagePackSerializer.Serialize(new Order2 {
                IsBuy = true, IsTip = false, OpenQuantity = 100, OrderId = 1001, Price = 400, Quantity = 100, Sequnce = 0, StopPrice = 0
            });

            fillJsonString = JsonConvert.SerializeObject(new Fill {
                MakerOrderId = 10001, MatchQuantity = 2000, MatchRate = 2400, TakerOrderId = 9999, Timestamp = 10303
            });
            fillBinary = FillSerializer.Serialize(new Fill {
                MakerOrderId = 10001, MatchQuantity = 2000, MatchRate = 2400, TakerOrderId = 9999, Timestamp = 10303
            });

            cancelJsonString = JsonConvert.SerializeObject(new CancelledOrder {
                OrderId = 1201, CancelReason = CancelReason.UserRequested, RemainingQuantity = 2000, Timestamp = 234
            });
            cancelBinary = CancelledOrderSerializer.Serialize(new CancelledOrder {
                OrderId = 1201, CancelReason = CancelReason.UserRequested, RemainingQuantity = 2000, Timestamp = 234
            });

            cancelRequestJsonString = JsonConvert.SerializeObject(new CancelRequest {
                OrderId = 1023
            });
            cancelRequestBinary = CancelRequestSerializer.Serialize(new CancelRequest {
                OrderId = 1023
            });

            orderTriggerBinary = OrderTriggerSerializer.Serialize(new OrderTrigger {
                OrderId = 3453, Timestamp = 35345
            });
            orderTriggerJsonString = JsonConvert.SerializeObject(new OrderTrigger {
                OrderId = 3453, Timestamp = 35345
            });

            bookRequestBinary     = BookRequestSerializer.Serialize(new BookRequest {
            });
            bookRequestJsonString = JsonConvert.SerializeObject(new BookRequest {
            });
            bookRequest2          = MessagePackSerializer.Serialize(new BookRequest2 {
            });

            bookJsonString = JsonConvert.SerializeObject(new BookDepth {
                Bid = bid, Ask = ask, LTP = 100, TimeStamp = 1234
            });
            bookBinary = BookSerializer.Serialize(book, 5, 100, 1234);
        }
 public void cancelRequestBinarySerialize()
 {
     var bytes = CancelRequestSerializer.Serialize(new CancelRequest {
         OrderId = 1023
     });
 }
 public void cancelRequestBinaryDeserialize()
 {
     var cancelRequest = CancelRequestSerializer.Deserialize(cancelRequestBinary);
 }
 public void Serialize_Doesnotthrowexception_Min()
 {
     var bytes = CancelRequestSerializer.Serialize(new CancelRequest {
         OrderId = ulong.MinValue
     });
 }
Example #17
0
 public void CancelRequestBinaryDeserialize()
 {
     CancelRequestSerializer.Deserialize(cancelRequestBinary);
 }
Example #18
0
        public void CancelRequestBinarySerialize()
        {
            Span <byte> bytes = stackalloc byte[CancelRequestSerializer.MessageSize];

            CancelRequestSerializer.Serialize(cancelRequest, bytes);
        }
Example #19
0
        public SerializeBenchmark()
        {
            book = new Book();
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = true, OpenQuantity = 1000, OrderId = 3434, Price = 234
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = true, OpenQuantity = 1000, OrderId = 3434, Price = 235
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = true, OpenQuantity = 1000, OrderId = 3435, Price = 236
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = true, OpenQuantity = 1000, OrderId = 3436, Price = 237
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = true, OpenQuantity = 1000, OrderId = 3437, Price = 238
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = false, OpenQuantity = 1000, OrderId = 3438, Price = 239
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = false, OpenQuantity = 1000, OrderId = 3439, Price = 240
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = false, OpenQuantity = 1000, OrderId = 3440, Price = 241
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = false, OpenQuantity = 1000, OrderId = 3441, Price = 242
            });
            book.AddOrderOpenBook(new Order {
                CancelOn = 1000, IsBuy = false, OpenQuantity = 1000, OrderId = 3442, Price = 243
            });
            bid = book.BidSide.Select(x => new KeyValuePair <Price, Quantity>(x.Key, x.Value.Quantity)).ToList();
            ask = book.AskSide.Select(x => new KeyValuePair <Price, Quantity>(x.Key, x.Value.Quantity)).ToList();

            var order = new Order()
            {
                CancelOn = 12345678, IsBuy = true, OrderId = 56789, Price = 404, OpenQuantity = 1000, OrderCondition = OrderCondition.ImmediateOrCancel, StopPrice = 9534, TotalQuantity = 7878234
            };

            orderJsonString = JsonConvert.SerializeObject(order);

            orderBinarySerialized = new byte[OrderSerializer.MessageSize];
            OrderSerializer.Serialize(order, orderBinarySerialized);

            orderMsgPck = MessagePackSerializer.Serialize(new Order2 {
                IsBuy = true, IsTip = false, OpenQuantity = 100, OrderId = 1001, Price = 400, Quantity = 100, Sequnce = 0, StopPrice = 0
            });

            fillJsonString = JsonConvert.SerializeObject(new Fill {
                MakerOrderId = 10001, MatchQuantity = 2000, MatchRate = 2400, TakerOrderId = 9999, Timestamp = 10303
            });
            fillBinary = new byte[FillSerializer.MessageSize];
            FillSerializer.Serialize(new Fill {
                MakerOrderId = 10001, MatchQuantity = 2000, MatchRate = 2400, TakerOrderId = 9999, Timestamp = 10303
            }, fillBinary);

            cancelJsonString = JsonConvert.SerializeObject(new CancelledOrder {
                OrderId = 1201, CancelReason = CancelReason.UserRequested, RemainingQuantity = 2000, Timestamp = 234
            });
            cancelBinary = new byte[CancelledOrderSerializer.MessageSize];
            CancelledOrderSerializer.Serialize(new CancelledOrder {
                OrderId = 1201, CancelReason = CancelReason.UserRequested, RemainingQuantity = 2000, Timestamp = 234
            }, cancelBinary);

            cancelRequestJsonString = JsonConvert.SerializeObject(new CancelRequest {
                OrderId = 1023
            });
            cancelRequestBinary = new byte[CancelRequestSerializer.MessageSize];
            CancelRequestSerializer.Serialize(new CancelRequest {
                OrderId = 1023
            }, cancelRequestBinary);

            orderTriggerBinary = new byte[OrderTriggerSerializer.MessageSize];
            OrderTriggerSerializer.Serialize(new OrderTrigger {
                OrderId = 3453, Timestamp = 35345
            }, orderTriggerBinary);
            orderTriggerJsonString = JsonConvert.SerializeObject(new OrderTrigger {
                OrderId = 3453, Timestamp = 35345
            });

            bookRequestBinary = new byte[BookRequestSerializer.MessageSize];
            BookRequestSerializer.Serialize(new BookRequest {
            }, bookRequestBinary);
            bookRequestJsonString = JsonConvert.SerializeObject(new BookRequest {
            });
            bookRequest2Bytes     = MessagePackSerializer.Serialize(new BookRequest2 {
            });

            bookDepth      = new BookDepth(1234, 100, bid, ask);
            bookJsonString = JsonConvert.SerializeObject(bookDepth);
            bookBinary     = new byte[OrderSerializer.MessageSize];
            BookSerializer.Serialize(bookDepth, bookBinary);

            fill = new Fill {
                MakerOrderId = 10001, MatchQuantity = 2000, MatchRate = 2400, TakerOrderId = 9999, Timestamp = 10303
            };
            order2 = new Order2 {
                IsBuy = true, IsTip = false, OpenQuantity = 100, OrderId = 1001, Price = 400, Quantity = 100, Sequnce = 0, StopPrice = 0
            };
            this.order = new Order {
                IsBuy = true, OpenQuantity = 100, OrderId = 1001, Price = 400, Sequnce = 0, TotalQuantity = 100, OrderCondition = OrderCondition.None, StopPrice = 0
            };
            cancelledOrder = new CancelledOrder {
                OrderId = 1201, CancelReason = CancelReason.UserRequested, RemainingQuantity = 2000, Timestamp = 234
            };
            cancelRequest = new CancelRequest {
                OrderId = 1023
            };
            orderTrigger = new OrderTrigger {
                OrderId = 3453, Timestamp = 35345
            };
            bookRequest = new BookRequest {
                LevelCount = 50
            };
            bookRequest2 = new BookRequest2 {
                LevelCount = 50
            };
        }
Example #20
0
 public void Serialize_Doesnotthrowexception_Max()
 {
     var bytes = CancelRequestSerializer.Serialize(new CancelRequest {
         OrderId = OrderId.MaxValue
     });
 }