1 /****************************************************************************
2 ** Copyright (c) 2001-2014
3 **
4 ** This file is part of the QuickFIX FIX Engine
5 **
6 ** This file may be distributed under the terms of the quickfixengine.org
7 ** license as defined by quickfixengine.org and appearing in the file
8 ** LICENSE included in the packaging of this file.
9 **
10 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
11 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
12 **
13 ** See http://www.quickfixengine.org/LICENSE for licensing information.
14 **
15 ** Contact ask@quickfixengine.org if any conditions of this licensing are
16 ** not clear to you.
17 **
18 ****************************************************************************/
19
20 #ifdef _MSC_VER
21 #pragma warning( disable : 4503 4355 4786 )
22 #else
23 #include "config.h"
24 #endif
25
26 #include <UnitTest++.h>
27 #include "OrderMatcher.h"
28
TEST(matchFull)29 TEST( matchFull )
30 {
31 OrderMatcher object;
32 Order order1("1", "LNUX", "OWNER1", "TARGET",
33 Order::buy, Order::limit, 12.32, 100);
34 Order order2("2", "LNUX", "OWNER2", "TARGET",
35 Order::sell, Order::limit, 12.32, 100);
36
37 CHECK(object.insert(order1));
38 CHECK(object.insert(order2));
39
40 std::queue<Order> orders;
41 CHECK(object.match("LNUX", orders));
42 CHECK_EQUAL(1U, orders.size());
43
44 Order matchedOrder1 = orders.front();
45 orders.pop();
46 Order matchedOrder2 = orders.front();
47 orders.pop();
48
49 CHECK_EQUAL("1", matchedOrder1.getClientID());
50 CHECK(matchedOrder1.isFilled());
51 CHECK(matchedOrder1.isClosed());
52 CHECK_EQUAL(0, matchedOrder1.getOpenQuantity());
53 CHECK_EQUAL(100, matchedOrder1.getExecutedQuantity());
54 CHECK_EQUAL(12.32, matchedOrder1.getAvgExecutedPrice());
55 CHECK_EQUAL(12.32, matchedOrder1.getLastExecutedPrice());
56 CHECK_EQUAL(100, matchedOrder1.getLastExecutedQuantity());
57
58 CHECK_EQUAL("2", matchedOrder2.getClientID());
59 CHECK(matchedOrder2.isFilled());
60 CHECK(matchedOrder2.isClosed());
61 CHECK_EQUAL(0, matchedOrder2.getOpenQuantity());
62 CHECK_EQUAL(100, matchedOrder2.getExecutedQuantity());
63 CHECK_EQUAL(12.32, matchedOrder2.getAvgExecutedPrice());
64 CHECK_EQUAL(12.32, matchedOrder2.getLastExecutedPrice());
65 CHECK_EQUAL(100, matchedOrder2.getLastExecutedQuantity());
66 }
67
TEST(matchPartial)68 TEST( matchPartial )
69 {
70 OrderMatcher object;
71 Order order1("1", "LNUX", "OWNER1", "TARGET",
72 Order::buy, Order::limit, 12.32, 100);
73 Order order2("2", "LNUX", "OWNER2", "TARGET",
74 Order::sell, Order::limit, 12.32, 50);
75 Order order3("3", "LNUX", "OWNER3", "TARGET",
76 Order::sell, Order::limit, 12.30, 50);
77
78 CHECK(object.insert(order1));
79 CHECK(object.insert(order2));
80
81 std::queue<Order> orders;
82 CHECK(object.match("LNUX", orders));
83 CHECK_EQUAL(2U, orders.size());
84
85 Order matchedOrder1 = orders.front();
86 orders.pop();
87 Order matchedOrder2 = orders.front();
88 orders.pop();
89
90 CHECK_EQUAL("1", matchedOrder1.getClientID());
91 CHECK(!matchedOrder1.isFilled());
92 CHECK(!matchedOrder1.isClosed());
93 CHECK_EQUAL(50, matchedOrder1.getOpenQuantity());
94 CHECK_EQUAL(50, matchedOrder1.getExecutedQuantity());
95 CHECK_EQUAL(12.32, matchedOrder1.getAvgExecutedPrice());
96 CHECK_EQUAL(12.32, matchedOrder1.getLastExecutedPrice());
97 CHECK_EQUAL(50, matchedOrder1.getLastExecutedQuantity());
98
99 CHECK_EQUAL("2", matchedOrder2.getClientID());
100 CHECK(matchedOrder2.isFilled());
101 CHECK(matchedOrder2.isClosed());
102 CHECK_EQUAL(0, matchedOrder2.getOpenQuantity());
103 CHECK_EQUAL(50, matchedOrder2.getExecutedQuantity());
104 CHECK_EQUAL(12.32, matchedOrder2.getAvgExecutedPrice());
105 CHECK_EQUAL(12.32, matchedOrder2.getLastExecutedPrice());
106 CHECK_EQUAL(50, matchedOrder2.getLastExecutedQuantity());
107
108 CHECK(object.insert(order3));
109 CHECK(object.match("LNUX", orders));
110 CHECK_EQUAL(2U, orders.size());
111
112 matchedOrder1 = orders.front();
113 orders.pop();
114 Order matchedOrder3 = orders.front();
115 orders.pop();
116
117 CHECK_EQUAL("1", matchedOrder1.getClientID());
118 CHECK(!matchedOrder1.isFilled());
119 CHECK(!matchedOrder1.isClosed());
120 CHECK_EQUAL(0, matchedOrder1.getOpenQuantity());
121 CHECK_EQUAL(100, matchedOrder1.getExecutedQuantity());
122 CHECK_EQUAL(12.31, matchedOrder1.getAvgExecutedPrice());
123 CHECK_EQUAL(12.30, matchedOrder1.getLastExecutedPrice());
124 CHECK_EQUAL(50, matchedOrder1.getLastExecutedQuantity());
125
126 CHECK_EQUAL("3", matchedOrder3.getClientID());
127 CHECK(matchedOrder3.isFilled());
128 CHECK(matchedOrder3.isClosed());
129 CHECK_EQUAL(0, matchedOrder3.getOpenQuantity());
130 CHECK_EQUAL(50, matchedOrder3.getExecutedQuantity());
131 CHECK_EQUAL(12.30, matchedOrder3.getAvgExecutedPrice());
132 CHECK_EQUAL(12.30, matchedOrder3.getLastExecutedPrice());
133 CHECK_EQUAL(50, matchedOrder3.getLastExecutedQuantity());
134 }
135
TEST(matchTimePriority)136 TEST( matchTimePriority )
137 {
138 OrderMatcher object;
139 Order order1("1", "LNUX", "OWNER1", "TARGET",
140 Order::sell, Order::limit, 12.32, 50);
141 Order order2("2", "LNUX", "OWNER2", "TARGET",
142 Order::sell, Order::limit, 12.32, 50);
143 Order order3("3", "LNUX", "OWNER3", "TARGET",
144 Order::buy, Order::limit, 12.32, 50);
145
146 CHECK(object.insert(order1));
147 CHECK(object.insert(order2));
148
149 std::queue<Order> orders;
150 CHECK(!object.match("LNUX", orders));
151 CHECK_EQUAL(0U, orders.size());
152
153 CHECK(object.insert(order3));
154
155 CHECK(object.match("LNUX", orders));
156 CHECK_EQUAL(2U, orders.size());
157
158 Order matchedOrder3 = orders.front();
159 orders.pop();
160 Order matchedOrder1 = orders.front();
161 orders.pop();
162
163 CHECK_EQUAL("1", matchedOrder1.getClientID());
164 CHECK_EQUAL("3", matchedOrder3.getClientID());
165 }
166
TEST(matchPricePriority)167 TEST( matchPricePriority )
168 {
169 OrderMatcher object;
170 Order order1("1", "LNUX", "OWNER1", "TARGET",
171 Order::sell, Order::limit, 12.32, 50);
172 Order order2("2", "LNUX", "OWNER2", "TARGET",
173 Order::sell, Order::limit, 12.31, 50);
174 Order order3("3", "LNUX", "OWNER3", "TARGET",
175 Order::buy, Order::limit, 12.32, 50);
176
177 CHECK(object.insert(order1));
178 CHECK(object.insert(order2));
179
180 std::queue<Order> orders;
181 CHECK(!object.match("LNUX", orders));
182 CHECK_EQUAL(0U, orders.size());
183
184 CHECK(object.insert(order3));
185
186 CHECK(object.match("LNUX", orders));
187 CHECK_EQUAL(2U, orders.size());
188
189 Order matchedOrder3 = orders.front();
190 orders.pop();
191 Order matchedOrder2 = orders.front();
192 orders.pop();
193
194 CHECK_EQUAL("2", matchedOrder2.getClientID());
195 CHECK_EQUAL("3", matchedOrder3.getClientID());
196 }
197
TEST(matchMultiple)198 TEST( matchMultiple )
199 {
200 OrderMatcher object;
201 Order order1("1", "LNUX", "OWNER1", "TARGET",
202 Order::sell, Order::limit, 12.32, 50);
203 Order order2("2", "LNUX", "OWNER2", "TARGET",
204 Order::sell, Order::limit, 12.30, 50);
205 Order order3("3", "LNUX", "OWNER3", "TARGET",
206 Order::buy, Order::limit, 12.32, 100);
207
208 CHECK(object.insert(order1));
209 CHECK(object.insert(order2));
210 CHECK(object.insert(order3));
211
212 std::queue<Order> orders;
213 CHECK(object.match("LNUX", orders));
214 CHECK_EQUAL(4U, orders.size());
215
216 Order matchedOrder3_1 = orders.front();
217 orders.pop();
218 Order matchedOrder2 = orders.front();
219 orders.pop();
220 Order matchedOrder3_2 = orders.front();
221 orders.pop();
222 Order matchedOrder1 = orders.front();
223 orders.pop();
224
225 CHECK_EQUAL("3", matchedOrder3_1.getClientID());
226 CHECK(!matchedOrder3_1.isFilled());
227 CHECK(!matchedOrder3_1.isClosed());
228 CHECK_EQUAL(50, matchedOrder3_1.getOpenQuantity());
229 CHECK_EQUAL(50, matchedOrder3_1.getExecutedQuantity());
230 CHECK_EQUAL(12.30, matchedOrder3_1.getAvgExecutedPrice());
231 CHECK_EQUAL(12.30, matchedOrder3_1.getLastExecutedPrice());
232 CHECK_EQUAL(50, matchedOrder3_1.getLastExecutedQuantity());
233
234 CHECK_EQUAL("2", matchedOrder2.getClientID());
235 CHECK(matchedOrder2.isFilled());
236 CHECK(matchedOrder2.isClosed());
237 CHECK_EQUAL(0, matchedOrder2.getOpenQuantity());
238 CHECK_EQUAL(50, matchedOrder2.getExecutedQuantity());
239 CHECK_EQUAL(12.3, matchedOrder2.getAvgExecutedPrice());
240 CHECK_EQUAL(12.3, matchedOrder2.getLastExecutedPrice());
241 CHECK_EQUAL(50, matchedOrder2.getLastExecutedQuantity());
242
243 CHECK_EQUAL("3", matchedOrder3_2.getClientID());
244 CHECK(matchedOrder3_2.isFilled());
245 CHECK(matchedOrder3_2.isClosed());
246 CHECK_EQUAL(0, matchedOrder3_2.getOpenQuantity());
247 CHECK_EQUAL(100, matchedOrder3_2.getExecutedQuantity());
248 CHECK_EQUAL(12.31, matchedOrder3_2.getAvgExecutedPrice());
249 CHECK_EQUAL(12.32, matchedOrder3_2.getLastExecutedPrice());
250 CHECK_EQUAL(50, matchedOrder3_2.getLastExecutedQuantity());
251
252 CHECK_EQUAL("1", matchedOrder1.getClientID());
253 CHECK(matchedOrder1.isFilled());
254 CHECK(matchedOrder1.isClosed());
255 CHECK_EQUAL(0, matchedOrder1.getOpenQuantity());
256 CHECK_EQUAL(50, matchedOrder1.getExecutedQuantity());
257 CHECK_EQUAL(12.32, matchedOrder1.getAvgExecutedPrice());
258 CHECK_EQUAL(12.32, matchedOrder1.getLastExecutedPrice());
259 CHECK_EQUAL(50, matchedOrder1.getLastExecutedQuantity());
260 }
261
TEST(overMatch)262 TEST( overMatch )
263 {
264 OrderMatcher object;
265 Order order1("1", "LNUX", "OWNER1", "TARGET",
266 Order::buy, Order::limit, 12.32, 100);
267 Order order2("2", "LNUX", "OWNER2", "TARGET",
268 Order::sell, Order::limit, 12.32, 110);
269 Order order3("3", "LNUX", "OWNER3", "TARGET",
270 Order::buy, Order::limit, 12.32, 100);
271
272 CHECK(object.insert(order1));
273 CHECK(object.insert(order2));
274
275 std::queue<Order> orders;
276 CHECK(object.match("LNUX", orders));
277 CHECK_EQUAL(2U, orders.size());
278
279 Order matchedOrder1 = orders.front();
280 orders.pop();
281 Order matchedOrder2 = orders.front();
282 orders.pop();
283
284 CHECK_EQUAL("1", matchedOrder1.getClientID());
285 CHECK(matchedOrder1.isFilled());
286 CHECK(matchedOrder1.isClosed());
287 CHECK_EQUAL(0, matchedOrder1.getOpenQuantity());
288 CHECK_EQUAL(100, matchedOrder1.getExecutedQuantity());
289 CHECK_EQUAL(12.32, matchedOrder1.getAvgExecutedPrice());
290 CHECK_EQUAL(12.32, matchedOrder1.getLastExecutedPrice());
291 CHECK_EQUAL(100, matchedOrder1.getLastExecutedQuantity());
292
293 CHECK_EQUAL("2", matchedOrder2.getClientID());
294 CHECK(!matchedOrder2.isFilled());
295 CHECK(!matchedOrder2.isClosed());
296 CHECK_EQUAL(10, matchedOrder2.getOpenQuantity());
297 CHECK_EQUAL(100, matchedOrder2.getExecutedQuantity());
298 CHECK_EQUAL(12.32, matchedOrder2.getAvgExecutedPrice());
299 CHECK_EQUAL(12.32, matchedOrder2.getLastExecutedPrice());
300 CHECK_EQUAL(100, matchedOrder2.getLastExecutedQuantity());
301
302 CHECK(object.insert(order3));
303 CHECK(object.match("LNUX", orders));
304 CHECK_EQUAL(2U, orders.size());
305
306 Order matchedOrder3 = orders.front();
307 orders.pop();
308 matchedOrder2 = orders.front();
309 orders.pop();
310
311 CHECK_EQUAL("3", matchedOrder3.getClientID());
312 CHECK(!matchedOrder3.isFilled());
313 CHECK(!matchedOrder3.isClosed());
314 CHECK_EQUAL(90, matchedOrder3.getOpenQuantity());
315 CHECK_EQUAL(10, matchedOrder3.getExecutedQuantity());
316 CHECK_EQUAL(12.32, matchedOrder3.getAvgExecutedPrice());
317 CHECK_EQUAL(12.32, matchedOrder3.getLastExecutedPrice());
318 CHECK_EQUAL(10, matchedOrder3.getLastExecutedQuantity());
319
320 CHECK_EQUAL("2", matchedOrder2.getClientID());
321 CHECK(matchedOrder2.isFilled());
322 CHECK(matchedOrder2.isClosed());
323 CHECK_EQUAL(0, matchedOrder2.getOpenQuantity());
324 CHECK_EQUAL(110, matchedOrder2.getExecutedQuantity());
325 CHECK_EQUAL(12.32, matchedOrder2.getAvgExecutedPrice());
326 CHECK_EQUAL(12.32, matchedOrder2.getLastExecutedPrice());
327 CHECK_EQUAL(10, matchedOrder2.getLastExecutedQuantity());
328
329 }
330