1 #include <msgpack.hpp>
2 #include <gtest/gtest.h>
3 #include <sstream>
4
TEST(pack,num)5 TEST(pack, num)
6 {
7 msgpack::sbuffer sbuf;
8 msgpack::pack(sbuf, 1);
9 }
10
11
TEST(pack,vector)12 TEST(pack, vector)
13 {
14 msgpack::sbuffer sbuf;
15 std::vector<int> vec;
16 vec.push_back(1);
17 vec.push_back(2);
18 vec.push_back(3);
19 msgpack::pack(sbuf, vec);
20 }
21
22
TEST(pack,to_ostream)23 TEST(pack, to_ostream)
24 {
25 std::ostringstream stream;
26 msgpack::pack(stream, 1);
27 }
28
29
30 struct myclass {
myclassmyclass31 myclass() : num(0), str("default") { }
32
myclassmyclass33 myclass(int num, const std::string& str) :
34 num(num), str(str) { }
35
~myclassmyclass36 ~myclass() { }
37
38 int num;
39 std::string str;
40
41 MSGPACK_DEFINE(num, str);
42 };
43
44
TEST(pack,myclass)45 TEST(pack, myclass)
46 {
47 msgpack::sbuffer sbuf;
48 myclass m(1, "msgpack");
49 msgpack::pack(sbuf, m);
50 }
51
52
TEST(unpack,int_ret_no_offset_no_ref)53 TEST(unpack, int_ret_no_offset_no_ref)
54 {
55 msgpack::sbuffer sbuf;
56 msgpack::pack(sbuf, 1);
57
58 msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
59 EXPECT_EQ(1, oh.get().as<int>());
60 }
61
TEST(unpack,int_ret_offset_no_ref)62 TEST(unpack, int_ret_offset_no_ref)
63 {
64 msgpack::sbuffer sbuf;
65 msgpack::pack(sbuf, 1);
66
67 std::size_t off = 0;
68
69 msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), off);
70 EXPECT_EQ(1, oh.get().as<int>());
71 EXPECT_EQ(off, sbuf.size());
72 }
73
TEST(unpack,int_ret_no_offset_ref)74 TEST(unpack, int_ret_no_offset_ref)
75 {
76 msgpack::sbuffer sbuf;
77 msgpack::pack(sbuf, 1);
78 bool referenced;
79
80 msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
81 EXPECT_EQ(1, oh.get().as<int>());
82 EXPECT_FALSE(referenced);
83 }
84
TEST(unpack,int_ret_offset_ref)85 TEST(unpack, int_ret_offset_ref)
86 {
87 msgpack::sbuffer sbuf;
88 msgpack::pack(sbuf, 1);
89 std::size_t off = 0;
90 bool referenced;
91
92 msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), off, referenced);
93 EXPECT_EQ(1, oh.get().as<int>());
94 EXPECT_FALSE(referenced);
95 EXPECT_EQ(off, sbuf.size());
96 }
97
98
TEST(unpack,int_no_offset_no_ref)99 TEST(unpack, int_no_offset_no_ref)
100 {
101 msgpack::sbuffer sbuf;
102 msgpack::pack(sbuf, 1);
103 msgpack::object_handle oh;
104
105 msgpack::unpack(oh, sbuf.data(), sbuf.size());
106 EXPECT_EQ(1, oh.get().as<int>());
107 }
108
TEST(unpack,int_offset_no_ref)109 TEST(unpack, int_offset_no_ref)
110 {
111 msgpack::sbuffer sbuf;
112 msgpack::pack(sbuf, 1);
113 msgpack::object_handle oh;
114
115 std::size_t off = 0;
116
117 msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
118 EXPECT_EQ(1, oh.get().as<int>());
119 EXPECT_EQ(off, sbuf.size());
120 }
121
TEST(unpack,int_no_offset_ref)122 TEST(unpack, int_no_offset_ref)
123 {
124 msgpack::sbuffer sbuf;
125 msgpack::pack(sbuf, 1);
126 msgpack::object_handle oh;
127 bool referenced;
128
129 msgpack::unpack(oh, sbuf.data(), sbuf.size(), referenced);
130 EXPECT_EQ(1, oh.get().as<int>());
131 EXPECT_FALSE(referenced);
132 }
133
TEST(unpack,int_offset_ref)134 TEST(unpack, int_offset_ref)
135 {
136 msgpack::sbuffer sbuf;
137 msgpack::pack(sbuf, 1);
138 msgpack::object_handle oh;
139 std::size_t off = 0;
140 bool referenced;
141
142 msgpack::unpack(oh, sbuf.data(), sbuf.size(), off, referenced);
143 EXPECT_EQ(1, oh.get().as<int>());
144 EXPECT_FALSE(referenced);
145 EXPECT_EQ(off, sbuf.size());
146 }
147
148 #if MSGPACK_DEFAULT_API_VERSION == 1
149
TEST(unpack,int_pointer_off_no_ref)150 TEST(unpack, int_pointer_off_no_ref)
151 {
152 msgpack::sbuffer sbuf;
153 msgpack::pack(sbuf, 1);
154 msgpack::object_handle oh;
155
156 std::size_t off = 0;
157
158 // obsolete
159 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
160 #pragma GCC diagnostic push
161 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
162 #endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
163 msgpack::unpack(&oh, sbuf.data(), sbuf.size(), &off);
164 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
165 #pragma GCC diagnostic pop
166 #endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
167 EXPECT_EQ(1, oh.get().as<int>());
168 EXPECT_EQ(off, sbuf.size());
169 }
170
TEST(unpack,int_pointer_off_no_ref_explicit)171 TEST(unpack, int_pointer_off_no_ref_explicit)
172 {
173 msgpack::sbuffer sbuf;
174 msgpack::pack(sbuf, 1);
175 msgpack::object_handle oh;
176
177 std::size_t off = 0;
178
179 // obsolete
180 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
181 #pragma GCC diagnostic push
182 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
183 #endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
184 msgpack::unpack(&oh, sbuf.data(), sbuf.size(), &off, MSGPACK_NULLPTR);
185 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
186 #pragma GCC diagnostic pop
187 #endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
188 EXPECT_EQ(1, oh.get().as<int>());
189 EXPECT_EQ(off, sbuf.size());
190 }
191
TEST(unpack,int_pointer_no_off_ref)192 TEST(unpack, int_pointer_no_off_ref)
193 {
194 msgpack::sbuffer sbuf;
195 msgpack::pack(sbuf, 1);
196 msgpack::object_handle oh;
197 bool referenced;
198
199 // obsolete
200 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
201 #pragma GCC diagnostic push
202 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
203 #endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
204 msgpack::unpack(&oh, sbuf.data(), sbuf.size(), MSGPACK_NULLPTR, &referenced);
205 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
206 #pragma GCC diagnostic pop
207 #endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
208 EXPECT_EQ(1, oh.get().as<int>());
209 EXPECT_FALSE(referenced);
210 }
211
TEST(unpack,int_pointer_off_ref)212 TEST(unpack, int_pointer_off_ref)
213 {
214 msgpack::sbuffer sbuf;
215 msgpack::pack(sbuf, 1);
216 msgpack::object_handle oh;
217 bool referenced;
218 std::size_t off = 0;
219
220 // obsolete
221 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
222 #pragma GCC diagnostic push
223 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
224 #endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
225 msgpack::unpack(&oh, sbuf.data(), sbuf.size(), &off, &referenced);
226 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
227 #pragma GCC diagnostic pop
228 #endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
229 EXPECT_EQ(1, oh.get().as<int>());
230 EXPECT_EQ(off, sbuf.size());
231 EXPECT_FALSE(referenced);
232 }
233
234
TEST(unpack,int_default_null_pointer)235 TEST(unpack, int_default_null_pointer)
236 {
237 msgpack::sbuffer sbuf;
238 msgpack::pack(sbuf, 1);
239 msgpack::object_handle oh;
240
241 // obsolete
242 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
243 #pragma GCC diagnostic push
244 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
245 #endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
246 msgpack::unpack(&oh, sbuf.data(), sbuf.size());
247 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
248 #pragma GCC diagnostic pop
249 #endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
250 EXPECT_EQ(1, oh.get().as<int>());
251 }
252
253 #endif // MSGPACK_DEFAULT_API_VERSION == 1
254
TEST(unpack,int_zone_no_offset_no_ref)255 TEST(unpack, int_zone_no_offset_no_ref)
256 {
257 msgpack::sbuffer sbuf;
258 msgpack::pack(sbuf, 1);
259
260 msgpack::zone z;
261 msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size());
262 EXPECT_EQ(1, obj.as<int>());
263 }
264
TEST(unpack,int_zone_offset_no_ref)265 TEST(unpack, int_zone_offset_no_ref)
266 {
267 msgpack::sbuffer sbuf;
268 msgpack::pack(sbuf, 1);
269
270 std::size_t off = 0;
271
272 msgpack::zone z;
273 msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size(), off);
274 EXPECT_EQ(1, obj.as<int>());
275 EXPECT_EQ(off, sbuf.size());
276 }
277
TEST(unpack,int_zone_no_offset_ref)278 TEST(unpack, int_zone_no_offset_ref)
279 {
280 msgpack::sbuffer sbuf;
281 msgpack::pack(sbuf, 1);
282 bool referenced;
283
284 msgpack::zone z;
285 msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size(), referenced);
286 EXPECT_EQ(1, obj.as<int>());
287 EXPECT_FALSE(referenced);
288 }
289
TEST(unpack,int_zone_offset_ref)290 TEST(unpack, int_zone_offset_ref)
291 {
292 msgpack::sbuffer sbuf;
293 msgpack::pack(sbuf, 1);
294 std::size_t off = 0;
295 bool referenced;
296
297 msgpack::zone z;
298 msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size(), off, referenced);
299 EXPECT_EQ(1, obj.as<int>());
300 EXPECT_FALSE(referenced);
301 EXPECT_EQ(off, sbuf.size());
302 }
303
304
TEST(unpack,sequence)305 TEST(unpack, sequence)
306 {
307 msgpack::sbuffer sbuf;
308 msgpack::pack(sbuf, 1);
309 msgpack::pack(sbuf, 2);
310 msgpack::pack(sbuf, 3);
311
312 std::size_t off = 0;
313
314 msgpack::object_handle oh;
315
316 msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
317 EXPECT_EQ(1, oh.get().as<int>());
318
319 msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
320 EXPECT_EQ(2, oh.get().as<int>());
321
322 msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
323 EXPECT_EQ(3, oh.get().as<int>());
324
325 EXPECT_EQ(off, sbuf.size());
326 }
327
328
TEST(unpack,convert_to_object_handle)329 TEST(unpack, convert_to_object_handle)
330 {
331 msgpack::sbuffer sbuf;
332 msgpack::pack(sbuf, 1);
333 msgpack::unpacked msg;
334
335 msgpack::unpack(msg, sbuf.data(), sbuf.size());
336 msgpack::object_handle oh(msgpack::move(msg));
337 EXPECT_EQ(1, oh.get().as<int>());
338
339 }
340
TEST(unpack,convert_to_object_handle_direct)341 TEST(unpack, convert_to_object_handle_direct)
342 {
343 msgpack::sbuffer sbuf;
344 msgpack::pack(sbuf, 1);
345 msgpack::object_handle oh(msgpack::unpack(sbuf.data(), sbuf.size()));
346 EXPECT_EQ(1, oh.get().as<int>());
347
348 }
349
TEST(unpack,convert_to_object_handle_direct_implicit)350 TEST(unpack, convert_to_object_handle_direct_implicit)
351 {
352 msgpack::sbuffer sbuf;
353 msgpack::pack(sbuf, 1);
354 msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
355 EXPECT_EQ(1, oh.get().as<int>());
356
357 }
358
TEST(unpack,insufficient_bytes_ref)359 TEST(unpack, insufficient_bytes_ref)
360 {
361 msgpack::sbuffer sbuf;
362 msgpack::pack(sbuf, 255); // uint8 (2bytes)
363
364 std::size_t off = 0;
365
366 msgpack::object_handle oh;
367 try {
368 msgpack::unpack(oh, sbuf.data(), 1, off);
369 EXPECT_TRUE(false);
370 }
371 catch (msgpack::insufficient_bytes const&) {
372 EXPECT_TRUE(true);
373 EXPECT_EQ(1u, off);
374 }
375 }
376
TEST(unpack,insufficient_bytes_object_handle)377 TEST(unpack, insufficient_bytes_object_handle)
378 {
379 msgpack::sbuffer sbuf;
380 msgpack::pack(sbuf, 255); // uint8 (2bytes)
381
382 std::size_t off = 0;
383
384 try {
385 msgpack::object_handle oh(msgpack::unpack(sbuf.data(), 1, off));
386 EXPECT_TRUE(false);
387 }
388 catch (msgpack::insufficient_bytes const&) {
389 EXPECT_TRUE(true);
390 EXPECT_EQ(1u, off);
391 }
392 }
393
TEST(unpack,insufficient_bytes_zone)394 TEST(unpack, insufficient_bytes_zone)
395 {
396 msgpack::sbuffer sbuf;
397 msgpack::pack(sbuf, 255); // uint8 (2bytes)
398
399 std::size_t off = 0;
400
401 try {
402 msgpack::zone z;
403 msgpack::unpack(z, sbuf.data(), 1, off);
404 EXPECT_TRUE(false);
405 }
406 catch (msgpack::insufficient_bytes const&) {
407 EXPECT_TRUE(true);
408 EXPECT_EQ(1u, off);
409 }
410 }
411
TEST(unpack,parse_error)412 TEST(unpack, parse_error)
413 {
414 msgpack::sbuffer sbuf;
415
416 char c = '\xc1';
417 sbuf.write(&c, 1);
418
419 bool thrown = false;
420 msgpack::object_handle oh;
421 try {
422 msgpack::unpack(oh, sbuf.data(), sbuf.size());
423 EXPECT_TRUE(false);
424 }
425 catch (msgpack::parse_error const&) {
426 thrown = true;
427 }
428 EXPECT_TRUE(thrown);
429 }
430
TEST(unpack,returned_parse_error)431 TEST(unpack, returned_parse_error)
432 {
433 msgpack::sbuffer sbuf;
434
435 char c = '\xc1';
436 sbuf.write(&c, 1);
437
438 bool thrown = false;
439 try {
440 msgpack::unpack(sbuf.data(), sbuf.size());
441 EXPECT_TRUE(false);
442 }
443 catch (msgpack::parse_error const&) {
444 thrown = true;
445 }
446 EXPECT_TRUE(thrown);
447 }
448
TEST(unpack,zone_parse_error)449 TEST(unpack, zone_parse_error)
450 {
451 msgpack::sbuffer sbuf;
452
453 char c = '\xc1';
454 sbuf.write(&c, 1);
455
456 bool thrown = false;
457 msgpack::zone z;
458 try {
459 msgpack::unpack(z, sbuf.data(), sbuf.size());
460 EXPECT_TRUE(false);
461 }
462 catch (msgpack::parse_error const&) {
463 thrown = true;
464 }
465 EXPECT_TRUE(thrown);
466 }
467
TEST(unpack,extra_bytes)468 TEST(unpack, extra_bytes)
469 {
470 msgpack::sbuffer sbuf;
471 msgpack::pack(sbuf, 1);
472
473 msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size() + 1);
474 EXPECT_EQ(1, oh.get().as<int>());
475 }
476
TEST(unpack,zone_extra_bytes)477 TEST(unpack, zone_extra_bytes)
478 {
479 msgpack::sbuffer sbuf;
480 msgpack::pack(sbuf, 1);
481
482 msgpack::zone z;
483 msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size() + 1);
484 EXPECT_EQ(1, obj.as<int>());
485 }
486
TEST(unpack,int_off_larger_than_length)487 TEST(unpack, int_off_larger_than_length)
488 {
489 msgpack::sbuffer sbuf;
490 msgpack::pack(sbuf, 1);
491
492 std::size_t off = 2;
493
494 bool thrown = false;
495 try {
496 msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), off);
497 }
498 catch (msgpack::insufficient_bytes const&) {
499 thrown = true;
500 }
501 EXPECT_TRUE(thrown);
502 EXPECT_EQ(off, 2u);
503 }
504