API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 23rd, 2015
278
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 12.11 KB | None | 0 0
raw download clone embed print report
  1. #include <stdafx.h>
  2. #include <gtest/gtest.h>
  3. #include <gmock/gmock.h>
  4. #include "texas/engine/MatcherNode.h"
  5. #include "texas/domain/OrderMock.h"
  6.  
  7. using namespace testing;
  8.  
  9. namespace texas {
  10.     namespace engine {
  11.  
  12.         class MatcherNodeStubbed : public MatcherNode {
  13.         public:
  14.             MatcherNodeStubbed(IOrderPtr order, bool checkResult)
  15.                 : MatcherNode(order), m_checkResult(checkResult) { }
  16.             MatcherNodeStubbed(IOrderPtr order) : MatcherNodeStubbed(order, false) { }
  17.             virtual ~MatcherNodeStubbed() { }
  18.             virtual bool CheckActivationConditions() { return m_checkResult; }
  19.             virtual void SetCheckActivationConditionsResult(bool result) { m_checkResult = result; }
  20.         private:
  21.             bool m_checkResult;
  22.         };
  23.  
  24.         class MatcherNodeTest : public Test {
  25.         protected:
  26.             ISecurityPtr m_security;
  27.             IOrderPtr m_order;
  28.             OrderMockPtr m_orderMock;
  29.             MatcherNodePtr m_node;
  30.             TickPtr m_tick1, m_tick2;
  31.  
  32.             virtual void SetUp() override {
  33.                 m_security = Security::NewRandom();
  34.                 m_order = Order::NewRandom(m_security);
  35.                 m_orderMock = make_shared<OrderMock>();
  36.                 m_node = make_shared<MatcherNodeStubbed>(m_order);
  37.                 m_tick1 = make_shared<Tick>(1, DateTime::New(2001, 9, 11, 8, 0, 0, 0), Decimal::New(42.13, 2), 1000);
  38.                 m_tick2 = make_shared<Tick>(Decimal::New(43.48, 2), 1100);
  39.             }
  40.  
  41.             virtual void TearDown() override {
  42.  
  43.             }
  44.  
  45.         };
  46.  
  47.         TEST_F(MatcherNodeTest, TestGetters) {
  48.             ASSERT_EQ(m_security, m_node->GetSecurity());
  49.             ASSERT_EQ(m_order, m_node->GetOrder());
  50.         }
  51.  
  52.         TEST_F(MatcherNodeTest, TestGetBidPriceMinusPenny) {
  53.             m_security->SetBidPrice(Decimal::New(120.05, 2));
  54.             ASSERT_TRUE(Decimal(120.04, 2).Equals(m_node->GetBidPriceMinusPenny()));
  55.         }
  56.  
  57.         TEST_F(MatcherNodeTest, TestGetAskPriceMinusPenny) {
  58.             m_security->SetAskPrice(Decimal::New(280.22, 2));
  59.             ASSERT_TRUE(Decimal(280.21, 2).Equals(m_node->GetAskPriceMinusPenny()));
  60.         }
  61.  
  62.         TEST_F(MatcherNodeTest, TestGetBidPricePlusPenny) {
  63.             m_security->SetBidPrice(Decimal::New(44.13, 2));
  64.             ASSERT_TRUE(Decimal(44.14, 2).Equals(m_node->GetBidPricePlusPenny()));
  65.         }
  66.  
  67.         TEST_F(MatcherNodeTest, TestGetAskPricePlusPenny) {
  68.             m_security->SetAskPrice(Decimal::New(82.91, 2));
  69.             ASSERT_TRUE(Decimal(82.92, 2).Equals(m_node->GetAskPricePlusPenny()));
  70.         }
  71.  
  72.         TEST_F(MatcherNodeTest, TestIsActive) {
  73.             m_node = make_shared<MatcherNodeStubbed>(m_orderMock);
  74.             EXPECT_CALL(*m_orderMock, IsActive())
  75.                 .WillOnce(Return(true))
  76.                 .WillOnce(Return(false));
  77.  
  78.             ASSERT_TRUE(m_node->IsActive());
  79.             ASSERT_FALSE(m_node->IsActive());
  80.         }
  81.  
  82.         TEST_F(MatcherNodeTest, TestIsTopActive) {
  83.             m_order->SetStatus(OrderStatus::TopActive);
  84.             ASSERT_TRUE(m_node->IsTopActive());
  85.  
  86.             m_order->SetStatus(OrderStatus::Active);
  87.             ASSERT_FALSE(m_node->IsTopActive());
  88.             m_order->SetStatus(OrderStatus::Cancelled);
  89.             ASSERT_FALSE(m_node->IsTopActive());
  90.             m_order->SetStatus(OrderStatus::Expired);
  91.             ASSERT_FALSE(m_node->IsTopActive());
  92.             m_order->SetStatus(OrderStatus::Filled);
  93.             ASSERT_FALSE(m_node->IsTopActive());
  94.             m_order->SetStatus(OrderStatus::MatchPending);
  95.             ASSERT_FALSE(m_node->IsTopActive());
  96.             m_order->SetStatus(OrderStatus::NonActive);
  97.             ASSERT_FALSE(m_node->IsTopActive());
  98.             m_order->SetStatus(OrderStatus::Matched);
  99.             ASSERT_FALSE(m_node->IsTopActive());
  100.         }
  101.  
  102.         TEST_F(MatcherNodeTest, TestIsCancelled) {
  103.             m_node = make_shared<MatcherNodeStubbed>(m_orderMock);
  104.             EXPECT_CALL(*m_orderMock, IsCancelled())
  105.                 .WillOnce(Return(false))
  106.                 .WillOnce(Return(true));
  107.  
  108.             ASSERT_FALSE(m_node->IsCancelled());
  109.             ASSERT_TRUE(m_node->IsCancelled());
  110.         }
  111.  
  112.         TEST_F(MatcherNodeTest, TestIsExpired) {
  113.             m_node = make_shared<MatcherNodeStubbed>(m_orderMock);
  114.             EXPECT_CALL(*m_orderMock, IsExpired())
  115.                 .WillOnce(Return(true))
  116.                 .WillOnce(Return(false));
  117.  
  118.             ASSERT_TRUE(m_node->IsExpired());
  119.             ASSERT_FALSE(m_node->IsExpired());
  120.         }
  121.  
  122.         TEST_F(MatcherNodeTest, TestIsNotActive) {
  123.             m_node = make_shared<MatcherNodeStubbed>(m_orderMock);
  124.             EXPECT_CALL(*m_orderMock, IsNotActive())
  125.                 .WillOnce(Return(false))
  126.                 .WillOnce(Return(true));
  127.  
  128.             ASSERT_FALSE(m_node->IsNotActive());
  129.             ASSERT_TRUE(m_node->IsNotActive());
  130.         }
  131.  
  132.         TEST_F(MatcherNodeTest, TestSetGetRank) {
  133.             ASSERT_EQ(0, m_node->GetRank());
  134.             m_node->SetRank(256);
  135.             ASSERT_EQ(256, m_node->GetRank());
  136.         }
  137.  
  138.         TEST_F(MatcherNodeTest, TestMarkAsTopActive) {
  139.             m_node->MarkAsTopActive();
  140.             ASSERT_EQ(OrderStatus::TopActive, m_order->GetStatus());
  141.         }
  142.  
  143.         TEST_F(MatcherNodeTest, TestGetSize) {
  144.             m_node = make_shared<MatcherNodeStubbed>(m_orderMock);
  145.             EXPECT_CALL(*m_orderMock, GetSize()).WillOnce(Return(220));
  146.  
  147.             ASSERT_EQ(220, m_node->GetSize());
  148.         }
  149.  
  150.         TEST_F(MatcherNodeTest, TestGetOrderId) {
  151.             m_node = make_shared<MatcherNodeStubbed>(m_orderMock);
  152.             EXPECT_CALL(*m_orderMock, GetId()).WillOnce(Return(128951));
  153.  
  154.             ASSERT_EQ(128951, m_node->GetOrderId());
  155.         }
  156.  
  157.         TEST_F(MatcherNodeTest, TestGetCustomerId) {
  158.             m_node = make_shared<MatcherNodeStubbed>(m_orderMock);
  159.             EXPECT_CALL(*m_orderMock, GetCustomerId()).WillOnce(Return(159128));
  160.  
  161.             ASSERT_EQ(159128, m_node->GetCustomerId());
  162.         }
  163.  
  164.         TEST_F(MatcherNodeTest, TestApplyActivationConditions) {
  165.             auto order1 = Order::NewRandom(m_security);
  166.             auto order2 = Order::NewRandom(m_security);
  167.             auto node1 = make_shared<MatcherNodeStubbed>(order1);
  168.             auto node2 = make_shared<MatcherNodeStubbed>(order2);
  169.             node1->SetCheckActivationConditionsResult(true);
  170.             node2->SetCheckActivationConditionsResult(false);
  171.  
  172.             ASSERT_TRUE(node1->ApplyActivationConditions());
  173.             ASSERT_EQ(OrderStatus::Active, order1->GetStatus());
  174.  
  175.             ASSERT_FALSE(node2->ApplyActivationConditions());
  176.             ASSERT_EQ(OrderStatus::NonActive, order2->GetStatus());
  177.         }
  178.  
  179.         TEST_F(MatcherNodeTest, TestAddExecution) {
  180.             auto e1 = make_shared<Execution>();
  181.             auto e2 = make_shared<Execution>();
  182.  
  183.             m_node->AddExecution(e1);
  184.             m_node->AddExecution(e2);
  185.  
  186.             ASSERT_EQ(e1, m_node->GetExecution(0));
  187.             ASSERT_EQ(e2, m_node->GetExecution(1));
  188.         }
  189.  
  190.         TEST_F(MatcherNodeTest, TestAddExecution_ThrowsIfNullPtr) {
  191.             ASSERT_THROW(m_node->AddExecution(ExecutionPtr()), std::exception);
  192.         }
  193.  
  194.         TEST_F(MatcherNodeTest, TestOpenExecution) {
  195.             auto buyer = make_shared<MatcherNodeStubbed>(Order::NewRandomLP_B(1, m_security));
  196.             auto seller = make_shared<MatcherNodeStubbed>(Order::NewRandomLP_S(1, m_security));
  197.             m_security->SetBidPrice(Decimal::New(112.34, 2));
  198.             m_security->SetAskPrice(Decimal::New(98.125, 3));
  199.             m_security->SetBidSize(894);
  200.             m_security->SetAskSize(900);
  201.  
  202.             auto x = buyer->OpenExecution(228);
  203.             ASSERT_TRUE((bool)x);
  204.             ASSERT_TRUE((bool)x->GetSnapShot1());
  205.             ASSERT_TRUE(x->GetSnapShot1()
  206.                 ->Equals(Tick(228, DateTime::Current(), Decimal::New(112.34, 2), 894)));
  207.  
  208.             x = seller->OpenExecution(442);
  209.             ASSERT_TRUE((bool)x);
  210.             ASSERT_TRUE((bool)x->GetSnapShot1());
  211.             ASSERT_TRUE(x->GetSnapShot1()
  212.                 ->Equals(Tick(442, DateTime::Current(), Decimal::New(98.125, 3), 900)));
  213.         }
  214.  
  215.         TEST_F(MatcherNodeTest, TestCloseExecution) {
  216.             auto buyer = make_shared<MatcherNodeStubbed>(Order::NewRandomLP_B(1, m_security));
  217.             auto seller = make_shared<MatcherNodeStubbed>(Order::NewRandomLP_S(1, m_security));
  218.             m_security->SetBidPrice(Decimal::New(24.12, 2));
  219.             m_security->SetAskPrice(Decimal::New(10.15, 2));
  220.             m_security->SetBidSize(871);
  221.             m_security->SetAskSize(130);
  222.  
  223.             auto x = buyer->OpenExecution(526);
  224.             buyer->CloseExecution();
  225.             ASSERT_TRUE((bool)x);
  226.             ASSERT_TRUE((bool)x->GetSnapShot2());
  227.             ASSERT_TRUE(x->GetSnapShot2()
  228.                 ->Equals(Tick(526, DateTime::Current(), Decimal::New(24.12, 2), 871)));
  229.  
  230.             x = seller->OpenExecution(882);
  231.             seller->CloseExecution();
  232.             ASSERT_TRUE((bool)x);
  233.             ASSERT_TRUE((bool)x->GetSnapShot2());
  234.             ASSERT_TRUE(x->GetSnapShot2()
  235.                 ->Equals(Tick(882, DateTime::Current(), Decimal::New(10.15, 2), 130)));
  236.         }
  237.  
  238.         TEST_F(MatcherNodeTest, TestCloseExecution_ThrowsIfNotStarted) {
  239.             ASSERT_THROW(m_node->CloseExecution(), std::exception);
  240.         }
  241.  
  242.         TEST_F(MatcherNodeTest, TestGetExecution_EmptyPtrIfNotExists) {
  243.             ASSERT_EQ(ExecutionPtr(), m_node->GetExecution(0));
  244.             ASSERT_EQ(ExecutionPtr(), m_node->GetExecution(1));
  245.             ASSERT_EQ(ExecutionPtr(), m_node->GetExecution(1024));
  246.         }
  247.  
  248.         TEST_F(MatcherNodeTest, TestGetExecution) {
  249.             auto x1 = m_node->OpenExecution(1);
  250.             auto x2 = m_node->OpenExecution(2);
  251.             auto x3 = m_node->OpenExecution(3);
  252.             ASSERT_EQ(x1, m_node->GetExecution(0));
  253.             ASSERT_EQ(x2, m_node->GetExecution(1));
  254.             ASSERT_EQ(x3, m_node->GetExecution(2));
  255.         }
  256.  
  257.         TEST_F(MatcherNodeTest, TestGetExecutionSnapShot1_SafeForWrongIndex) {
  258.             ASSERT_FALSE((bool)m_node->GetExecutionSnapShot1());
  259.             ASSERT_FALSE((bool)m_node->GetExecutionSnapShot1(1));
  260.             ASSERT_FALSE((bool)m_node->GetExecutionSnapShot1(2000));
  261.         }
  262.  
  263.         TEST_F(MatcherNodeTest, TestGetExecutionSnapShot2_SafeForWrongIndex) {
  264.             ASSERT_FALSE((bool)m_node->GetExecutionSnapShot2());
  265.             ASSERT_FALSE((bool)m_node->GetExecutionSnapShot2(1));
  266.             ASSERT_FALSE((bool)m_node->GetExecutionSnapShot2(2000));
  267.         }
  268.  
  269.         TEST_F(MatcherNodeTest, TestGetExecutionSnapShot1) {
  270.             auto x1 = m_node->OpenExecution(215);
  271.             auto x2 = m_node->OpenExecution(216);
  272.             x1->SetSnapShot1(m_tick1);
  273.             x2->SetSnapShot1(m_tick2);
  274.  
  275.             ASSERT_EQ(m_tick1, m_node->GetExecutionSnapShot1(0));
  276.             ASSERT_EQ(m_tick2, m_node->GetExecutionSnapShot1(1));
  277.         }
  278.  
  279.         TEST_F(MatcherNodeTest, TestGetExecutionSnapShot2) {
  280.             auto x1 = m_node->OpenExecution(215);
  281.             auto x2 = m_node->OpenExecution(216);
  282.             x1->SetSnapShot2(m_tick1);
  283.             x2->SetSnapShot2(m_tick2);
  284.  
  285.             ASSERT_EQ(m_tick1, m_node->GetExecutionSnapShot2(0));
  286.             ASSERT_EQ(m_tick2, m_node->GetExecutionSnapShot2(1));
  287.         }
  288.  
  289.         TEST_F(MatcherNodeTest, TestGetSetMatch) {
  290.             auto x = m_node->GetMatch();
  291.             ASSERT_FALSE((bool)x);
  292.  
  293.             auto time = DateTime::Current();
  294.             x = make_shared<Tick>(99999, time, Decimal::New(524.28, 2), 10);
  295.             m_node->SetMatch(x);
  296.             ASSERT_EQ(x, m_node->GetMatch());
  297.         }
  298.  
  299.         TEST_F(MatcherNodeTest, TestSetOrderStatus) {
  300.             m_node->SetOrderStatus(OrderStatus::Filled);
  301.             ASSERT_EQ(OrderStatus::Filled, m_order->GetStatus());
  302.             m_node->SetOrderStatus(OrderStatus::Matched);
  303.             ASSERT_EQ(OrderStatus::Matched, m_order->GetStatus());
  304.         }
  305.  
  306.         TEST_F(MatcherNodeTest, TestFailedExecutionCounter) {
  307.             ASSERT_EQ(0, m_node->GetFailedExecutionCounter());
  308.             ASSERT_EQ(1, m_node->IncrementFailedExecutionCounter());
  309.             ASSERT_EQ(1, m_node->GetFailedExecutionCounter());
  310.             ASSERT_EQ(2, m_node->IncrementFailedExecutionCounter());
  311.             ASSERT_EQ(3, m_node->IncrementFailedExecutionCounter());
  312.             ASSERT_EQ(4, m_node->IncrementFailedExecutionCounter());
  313.             ASSERT_EQ(4, m_node->GetFailedExecutionCounter());
  314.         }
  315.  
  316.         TEST_F(MatcherNodeTest, TestGetSnapShotOfCurrentPriceAndSize_B) {
  317.             auto node = make_shared<MatcherNodeStubbed>(Order::NewRandomLP_B(1, m_security));
  318.             m_security->SetBidPrice(Decimal::New(112.34, 2));
  319.             m_security->SetBidSize(894);
  320.  
  321.             auto x = node->GetSnapShotOfCurrentPriceAndSize(1025);
  322.             ASSERT_TRUE((bool)x);
  323.             ASSERT_TRUE(x->Equals(Tick(1025, DateTime::Current(), Decimal::New(112.34, 2), 894)));
  324.         }
  325.  
  326.         TEST_F(MatcherNodeTest, TestGetSnapShotOfCurrentPriceAndSize_S) {
  327.             auto node = make_shared<MatcherNodeStubbed>(Order::NewRandomLP_S(1, m_security));
  328.             m_security->SetAskPrice(Decimal::New(98.125, 3));
  329.             m_security->SetAskSize(900);
  330.  
  331.             auto x = node->GetSnapShotOfCurrentPriceAndSize(825);
  332.             ASSERT_TRUE((bool)x);
  333.             ASSERT_TRUE(x->Equals(Tick(825, DateTime::Current(), Decimal::New(98.125, 3), 900)));
  334.         }
  335.  
  336.         TEST_F(MatcherNodeTest, TestIsExecutionGranted) {
  337.             m_node = make_shared<MatcherNodeStubbed>(m_orderMock);
  338.             EXPECT_CALL(*m_orderMock, GetStatus())
  339.                 .WillOnce(Return(OrderStatus::Active))
  340.                 .WillOnce(Return(OrderStatus::Matched));
  341.  
  342.             ASSERT_FALSE(m_node->IsExecutionGranted());
  343.             ASSERT_TRUE(m_node->IsExecutionGranted());
  344.         }
  345.  
  346.         TEST_F(MatcherNodeTest, TestGetExecutionCounter) {
  347.             ASSERT_EQ(0, m_node->GetExecutionCounter());
  348.             m_node->OpenExecution(1);
  349.             ASSERT_EQ(1, m_node->GetExecutionCounter());
  350.             m_node->OpenExecution(2);
  351.             ASSERT_EQ(2, m_node->GetExecutionCounter());
  352.             ASSERT_EQ(2, m_node->GetExecutionCounter());
  353.         }
  354.  
  355.     }
  356. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!