1 #include "msgpack.hpp"
2
3 #include <cmath>
4 #include <string>
5 #include <vector>
6 #include <map>
7 #include <deque>
8 #include <set>
9 #include <list>
10 #include <limits>
11
12 #if defined(__GNUC__)
13 #pragma GCC diagnostic push
14 #pragma GCC diagnostic ignored "-Wconversion"
15 #endif //defined(__GNUC__)
16
17 #include <gtest/gtest.h>
18
19 #if defined(__GNUC__)
20 #pragma GCC diagnostic pop
21 #endif //defined(__GNUC__)
22
23 #if defined(_MSC_VER) || defined(__MINGW32__)
24 #define msgpack_rand() ((double)rand() / RAND_MAX)
25 #else // _MSC_VER || __MINGW32__
26 #define msgpack_rand() drand48()
27 #endif // _MSC_VER || __MINGW32__
28
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 using namespace std;
34
35 const unsigned int kLoop = 10000;
36 const unsigned int kElements = 100;
37 const double kEPS = 1e-10;
38
39 #define GEN_TEST(test_type) \
40 do { \
41 vector<test_type> v; \
42 v.push_back(0); \
43 v.push_back(1); \
44 v.push_back(2); \
45 v.push_back(numeric_limits<test_type>::min()); \
46 v.push_back(numeric_limits<test_type>::max()); \
47 for (unsigned int i = 0; i < kLoop; i++) \
48 v.push_back(static_cast<test_type>(rand())); \
49 for (unsigned int i = 0; i < v.size() ; i++) { \
50 msgpack::sbuffer sbuf; \
51 test_type val1 = v[i]; \
52 msgpack::pack(sbuf, val1); \
53 msgpack::object_handle oh = \
54 msgpack::unpack(sbuf.data(), sbuf.size()); \
55 EXPECT_EQ(val1, oh.get().as<test_type>()); \
56 } \
57 } while(0)
58
TEST(MSGPACK,simple_buffer_char)59 TEST(MSGPACK, simple_buffer_char)
60 {
61 GEN_TEST(char);
62 }
63
TEST(MSGPACK,simple_buffer_signed_char)64 TEST(MSGPACK, simple_buffer_signed_char)
65 {
66 GEN_TEST(signed char);
67 }
68
TEST(MSGPACK,simple_buffer_unsigned_char)69 TEST(MSGPACK, simple_buffer_unsigned_char)
70 {
71 GEN_TEST(unsigned char);
72 }
73
74
TEST(MSGPACK,simple_buffer_short)75 TEST(MSGPACK, simple_buffer_short)
76 {
77 GEN_TEST(short);
78 }
79
TEST(MSGPACK,simple_buffer_int)80 TEST(MSGPACK, simple_buffer_int)
81 {
82 GEN_TEST(int);
83 }
84
TEST(MSGPACK,simple_buffer_long)85 TEST(MSGPACK, simple_buffer_long)
86 {
87 GEN_TEST(long);
88 }
89
TEST(MSGPACK,simple_buffer_long_long)90 TEST(MSGPACK, simple_buffer_long_long)
91 {
92 GEN_TEST(long long);
93 }
94
TEST(MSGPACK,simple_buffer_unsigned_short)95 TEST(MSGPACK, simple_buffer_unsigned_short)
96 {
97 GEN_TEST(unsigned short);
98 }
99
TEST(MSGPACK,simple_buffer_unsigned_int)100 TEST(MSGPACK, simple_buffer_unsigned_int)
101 {
102 GEN_TEST(unsigned int);
103 }
104
TEST(MSGPACK,simple_buffer_unsigned_long)105 TEST(MSGPACK, simple_buffer_unsigned_long)
106 {
107 GEN_TEST(unsigned long);
108 }
109
TEST(MSGPACK,simple_buffer_unsigned_long_long)110 TEST(MSGPACK, simple_buffer_unsigned_long_long)
111 {
112 GEN_TEST(unsigned long long);
113 }
114
TEST(MSGPACK,simple_buffer_uint8)115 TEST(MSGPACK, simple_buffer_uint8)
116 {
117 GEN_TEST(uint8_t);
118 }
119
TEST(MSGPACK,simple_buffer_uint16)120 TEST(MSGPACK, simple_buffer_uint16)
121 {
122 GEN_TEST(uint16_t);
123 }
124
TEST(MSGPACK,simple_buffer_uint32)125 TEST(MSGPACK, simple_buffer_uint32)
126 {
127 GEN_TEST(uint32_t);
128 }
129
TEST(MSGPACK,simple_buffer_uint64)130 TEST(MSGPACK, simple_buffer_uint64)
131 {
132 GEN_TEST(uint64_t);
133 }
134
TEST(MSGPACK,simple_buffer_int8)135 TEST(MSGPACK, simple_buffer_int8)
136 {
137 GEN_TEST(int8_t);
138 }
139
TEST(MSGPACK,simple_buffer_int16)140 TEST(MSGPACK, simple_buffer_int16)
141 {
142 GEN_TEST(int16_t);
143 }
144
TEST(MSGPACK,simple_buffer_int32)145 TEST(MSGPACK, simple_buffer_int32)
146 {
147 GEN_TEST(int32_t);
148 }
149
TEST(MSGPACK,simple_buffer_int64)150 TEST(MSGPACK, simple_buffer_int64)
151 {
152 GEN_TEST(int64_t);
153 }
154
155 #if !defined(_MSC_VER) || _MSC_VER >=1800
156
TEST(MSGPACK,simple_buffer_float)157 TEST(MSGPACK, simple_buffer_float)
158 {
159 vector<float> v;
160 v.push_back(0.0);
161 v.push_back(-0.0);
162 v.push_back(1.0);
163 v.push_back(-1.0);
164 v.push_back(numeric_limits<float>::min());
165 v.push_back(numeric_limits<float>::max());
166 v.push_back(nanf("tag"));
167 if (numeric_limits<float>::has_infinity) {
168 v.push_back(numeric_limits<float>::infinity());
169 v.push_back(-numeric_limits<float>::infinity());
170 }
171 if (numeric_limits<float>::has_quiet_NaN) {
172 v.push_back(numeric_limits<float>::quiet_NaN());
173 }
174 if (numeric_limits<float>::has_signaling_NaN) {
175 v.push_back(numeric_limits<float>::signaling_NaN());
176 }
177
178 for (unsigned int i = 0; i < kLoop; i++) {
179 v.push_back(static_cast<float>(msgpack_rand()));
180 v.push_back(static_cast<float>(-msgpack_rand()));
181 }
182 for (unsigned int i = 0; i < v.size() ; i++) {
183 msgpack::sbuffer sbuf;
184 float val1 = v[i];
185 msgpack::pack(sbuf, val1);
186 msgpack::object_handle oh =
187 msgpack::unpack(sbuf.data(), sbuf.size());
188 float val2 = oh.get().as<float>();
189
190 if (std::isnan(val1))
191 EXPECT_TRUE(std::isnan(val2));
192 else if (std::isinf(val1))
193 EXPECT_TRUE(std::isinf(val2));
194 else
195 EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
196 }
197 }
198
199 #endif // !defined(_MSC_VER) || _MSC_VER >=1800
200
201 namespace {
202 template<typename F, typename I>
203 struct TypePair {
204 typedef F float_type;
205 typedef I integer_type;
206 };
207 } // namespace
208
209 template <typename T>
210 class IntegerToFloatingPointTest : public testing::Test {
211 };
212 TYPED_TEST_CASE_P(IntegerToFloatingPointTest);
213
TYPED_TEST_P(IntegerToFloatingPointTest,simple_buffer)214 TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer)
215 {
216 typedef typename TypeParam::float_type float_type;
217 typedef typename TypeParam::integer_type integer_type;
218 vector<integer_type> v;
219 v.push_back(0);
220 v.push_back(1);
221 if (numeric_limits<integer_type>::is_signed) v.push_back(static_cast<integer_type>(-1));
222 else v.push_back(2);
223 for (unsigned int i = 0; i < kLoop; i++) {
224 v.push_back(rand() % 0x7FFFFF);
225 }
226 for (unsigned int i = 0; i < v.size() ; i++) {
227 msgpack::sbuffer sbuf;
228 integer_type val1 = v[i];
229 msgpack::pack(sbuf, val1);
230 msgpack::object_handle oh =
231 msgpack::unpack(sbuf.data(), sbuf.size());
232 float_type val2 = oh.get().as<float_type>();
233 EXPECT_TRUE(fabs(val2 - static_cast<float_type>(val1)) <= kEPS);
234 }
235 }
236
237 REGISTER_TYPED_TEST_CASE_P(IntegerToFloatingPointTest,
238 simple_buffer);
239
240 typedef testing::Types<TypePair<float, signed long long>,
241 TypePair<float, unsigned long long>,
242 TypePair<double, signed long long>,
243 TypePair<double, unsigned long long> > IntegerToFloatingPointTestTypes;
244 INSTANTIATE_TYPED_TEST_CASE_P(IntegerToFloatingPointTestInstance,
245 IntegerToFloatingPointTest,
246 IntegerToFloatingPointTestTypes);
247
248 #if !defined(_MSC_VER) || _MSC_VER >=1800
249
TEST(MSGPACK,simple_buffer_double)250 TEST(MSGPACK, simple_buffer_double)
251 {
252 vector<double> v;
253 v.push_back(0.0);
254 v.push_back(-0.0);
255 v.push_back(1.0);
256 v.push_back(-1.0);
257 v.push_back(numeric_limits<double>::min());
258 v.push_back(numeric_limits<double>::max());
259 v.push_back(nanf("tag"));
260 if (numeric_limits<double>::has_infinity) {
261 v.push_back(numeric_limits<double>::infinity());
262 v.push_back(-numeric_limits<double>::infinity());
263 }
264 if (numeric_limits<double>::has_quiet_NaN) {
265 v.push_back(numeric_limits<double>::quiet_NaN());
266 }
267 if (numeric_limits<double>::has_signaling_NaN) {
268 v.push_back(numeric_limits<double>::signaling_NaN());
269 }
270 for (unsigned int i = 0; i < kLoop; i++) {
271 v.push_back(msgpack_rand());
272 v.push_back(-msgpack_rand());
273 }
274
275 for (unsigned int i = 0; i < kLoop; i++) {
276 v.push_back(msgpack_rand());
277 v.push_back(-msgpack_rand());
278 }
279 for (unsigned int i = 0; i < v.size() ; i++) {
280 msgpack::sbuffer sbuf;
281 double val1 = v[i];
282 msgpack::pack(sbuf, val1);
283 msgpack::object_handle oh =
284 msgpack::unpack(sbuf.data(), sbuf.size());
285 double val2 = oh.get().as<double>();
286
287 if (std::isnan(val1))
288 EXPECT_TRUE(std::isnan(val2));
289 else if (std::isinf(val1))
290 EXPECT_TRUE(std::isinf(val2));
291 else
292 EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
293 }
294 }
295
296 #endif // !defined(_MSC_VER) || _MSC_VER >=1800
297
TEST(MSGPACK,simple_buffer_nil)298 TEST(MSGPACK, simple_buffer_nil)
299 {
300 msgpack::sbuffer sbuf;
301 msgpack::packer<msgpack::sbuffer> packer(sbuf);
302 packer.pack_nil();
303 msgpack::object_handle oh =
304 msgpack::unpack(sbuf.data(), sbuf.size());
305 EXPECT_EQ(oh.get().type, msgpack::type::NIL);
306 }
307
TEST(MSGPACK,simple_buffer_true)308 TEST(MSGPACK, simple_buffer_true)
309 {
310 msgpack::sbuffer sbuf;
311 bool val1 = true;
312 msgpack::pack(sbuf, val1);
313 msgpack::object_handle oh =
314 msgpack::unpack(sbuf.data(), sbuf.size());
315 bool val2 = oh.get().as<bool>();
316 EXPECT_EQ(val1, val2);
317 }
318
TEST(MSGPACK,simple_buffer_false)319 TEST(MSGPACK, simple_buffer_false)
320 {
321 msgpack::sbuffer sbuf;
322 bool val1 = false;
323 msgpack::pack(sbuf, val1);
324 msgpack::object_handle oh =
325 msgpack::unpack(sbuf.data(), sbuf.size());
326 bool val2 = oh.get().as<bool>();
327 EXPECT_EQ(val1, val2);
328 }
329
TEST(MSGPACK,simple_buffer_fixext1)330 TEST(MSGPACK, simple_buffer_fixext1)
331 {
332 msgpack::sbuffer sbuf;
333 msgpack::packer<msgpack::sbuffer> packer(sbuf);
334 char const buf [] = { 2 };
335
336 packer.pack_ext(sizeof(buf), 1);
337 packer.pack_ext_body(buf, sizeof(buf));
338 msgpack::object_handle oh =
339 msgpack::unpack(sbuf.data(), sbuf.size());
340 EXPECT_EQ(1ul, oh.get().via.ext.size);
341 EXPECT_EQ(1, oh.get().via.ext.type());
342 EXPECT_EQ(2, oh.get().via.ext.data()[0]);
343
344 msgpack::sbuffer sbuf2;
345 msgpack::pack(sbuf2, oh.get());
346 msgpack::object_handle oh2 =
347 msgpack::unpack(sbuf2.data(), sbuf2.size());
348 EXPECT_EQ(1ul, oh2.get().via.ext.size);
349 EXPECT_EQ(1, oh2.get().via.ext.type());
350 EXPECT_EQ(2, oh2.get().via.ext.data()[0]);
351
352 EXPECT_EQ(oh.get(), oh2.get());
353 }
354
TEST(MSGPACK,simple_buffer_fixext2)355 TEST(MSGPACK, simple_buffer_fixext2)
356 {
357 msgpack::sbuffer sbuf;
358 msgpack::packer<msgpack::sbuffer> packer(sbuf);
359 char const buf [] = { 2, 3 };
360
361 packer.pack_ext(sizeof(buf), 0);
362 packer.pack_ext_body(buf, sizeof(buf));
363 msgpack::object_handle oh =
364 msgpack::unpack(sbuf.data(), sbuf.size());
365 EXPECT_EQ(2ul, oh.get().via.ext.size);
366 EXPECT_EQ(0, oh.get().via.ext.type());
367 EXPECT_TRUE(
368 std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
369
370 msgpack::sbuffer sbuf2;
371 msgpack::pack(sbuf2, oh.get());
372 msgpack::object_handle oh2 =
373 msgpack::unpack(sbuf2.data(), sbuf2.size());
374 EXPECT_EQ(2ul, oh2.get().via.ext.size);
375 EXPECT_EQ(0, oh2.get().via.ext.type());
376 EXPECT_TRUE(
377 std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
378
379 EXPECT_EQ(oh.get(), oh2.get());
380 }
381
TEST(MSGPACK,simple_buffer_fixext4)382 TEST(MSGPACK, simple_buffer_fixext4)
383 {
384 msgpack::sbuffer sbuf;
385 msgpack::packer<msgpack::sbuffer> packer(sbuf);
386 char const buf [] = { 2, 3, 4, 5 };
387
388 packer.pack_ext(sizeof(buf), 1);
389 packer.pack_ext_body(buf, sizeof(buf));
390 msgpack::object_handle oh =
391 msgpack::unpack(sbuf.data(), sbuf.size());
392 EXPECT_EQ(4ul, oh.get().via.ext.size);
393 EXPECT_EQ(1, oh.get().via.ext.type());
394 EXPECT_TRUE(
395 std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
396
397 msgpack::sbuffer sbuf2;
398 msgpack::pack(sbuf2, oh.get());
399 msgpack::object_handle oh2 =
400 msgpack::unpack(sbuf2.data(), sbuf2.size());
401 EXPECT_EQ(4ul, oh2.get().via.ext.size);
402 EXPECT_EQ(1, oh2.get().via.ext.type());
403 EXPECT_TRUE(
404 std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
405
406 EXPECT_EQ(oh.get(), oh2.get());
407 }
408
TEST(MSGPACK,simple_buffer_fixext8)409 TEST(MSGPACK, simple_buffer_fixext8)
410 {
411 msgpack::sbuffer sbuf;
412 msgpack::packer<msgpack::sbuffer> packer(sbuf);
413 char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 };
414
415 packer.pack_ext(sizeof(buf), 1);
416 packer.pack_ext_body(buf, sizeof(buf));
417 msgpack::object_handle oh =
418 msgpack::unpack(sbuf.data(), sbuf.size());
419 EXPECT_EQ(8ul, oh.get().via.ext.size);
420 EXPECT_EQ(1, oh.get().via.ext.type());
421 EXPECT_TRUE(
422 std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
423
424 msgpack::sbuffer sbuf2;
425 msgpack::pack(sbuf2, oh.get());
426 msgpack::object_handle oh2 =
427 msgpack::unpack(sbuf2.data(), sbuf2.size());
428 EXPECT_EQ(8ul, oh2.get().via.ext.size);
429 EXPECT_EQ(1, oh2.get().via.ext.type());
430 EXPECT_TRUE(
431 std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
432
433 EXPECT_EQ(oh.get(), oh2.get());
434 }
435
TEST(MSGPACK,simple_buffer_fixext16)436 TEST(MSGPACK, simple_buffer_fixext16)
437 {
438 msgpack::sbuffer sbuf;
439 msgpack::packer<msgpack::sbuffer> packer(sbuf);
440 char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };
441
442 packer.pack_ext(sizeof(buf), 1);
443 packer.pack_ext_body(buf, sizeof(buf));
444 msgpack::object_handle oh =
445 msgpack::unpack(sbuf.data(), sbuf.size());
446 EXPECT_EQ(16ul, oh.get().via.ext.size);
447 EXPECT_EQ(1, oh.get().via.ext.type());
448 EXPECT_TRUE(
449 std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
450
451 msgpack::sbuffer sbuf2;
452 msgpack::pack(sbuf2, oh.get());
453 msgpack::object_handle oh2 =
454 msgpack::unpack(sbuf2.data(), sbuf2.size());
455 EXPECT_EQ(16ul, oh2.get().via.ext.size);
456 EXPECT_EQ(1, oh2.get().via.ext.type());
457 EXPECT_TRUE(
458 std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
459
460 EXPECT_EQ(oh.get(), oh2.get());
461 }
462
TEST(MSGPACK,simple_buffer_fixext_1byte_0)463 TEST(MSGPACK, simple_buffer_fixext_1byte_0)
464 {
465 std::size_t const size = 0;
466 msgpack::sbuffer sbuf;
467 msgpack::packer<msgpack::sbuffer> packer(sbuf);
468
469 packer.pack_ext(size, 77);
470 msgpack::object_handle oh =
471 msgpack::unpack(sbuf.data(), sbuf.size());
472 EXPECT_EQ(size, oh.get().via.ext.size);
473 EXPECT_EQ(77, oh.get().via.ext.type());
474 }
475
TEST(MSGPACK,simple_buffer_fixext_1byte_255)476 TEST(MSGPACK, simple_buffer_fixext_1byte_255)
477 {
478 std::size_t const size = 255;
479 msgpack::sbuffer sbuf;
480 msgpack::packer<msgpack::sbuffer> packer(sbuf);
481 char buf[size];
482 for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
483 packer.pack_ext(sizeof(buf), 77);
484 packer.pack_ext_body(buf, sizeof(buf));
485
486 msgpack::object_handle oh =
487 msgpack::unpack(sbuf.data(), sbuf.size());
488 EXPECT_EQ(size, oh.get().via.ext.size);
489 EXPECT_EQ(77, oh.get().via.ext.type());
490 EXPECT_TRUE(
491 std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
492
493 msgpack::sbuffer sbuf2;
494 msgpack::pack(sbuf2, oh.get());
495 msgpack::object_handle oh2 =
496 msgpack::unpack(sbuf2.data(), sbuf2.size());
497 EXPECT_EQ(size, oh2.get().via.ext.size);
498 EXPECT_EQ(77, oh2.get().via.ext.type());
499 EXPECT_TRUE(
500 std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
501
502 EXPECT_EQ(oh.get(), oh2.get());
503 }
504
TEST(MSGPACK,simple_buffer_fixext_2byte_256)505 TEST(MSGPACK, simple_buffer_fixext_2byte_256)
506 {
507 std::size_t const size = 256;
508 msgpack::sbuffer sbuf;
509 msgpack::packer<msgpack::sbuffer> packer(sbuf);
510 char buf[size];
511 for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
512 packer.pack_ext(sizeof(buf), 77);
513 packer.pack_ext_body(buf, sizeof(buf));
514
515 msgpack::object_handle oh =
516 msgpack::unpack(sbuf.data(), sbuf.size());
517 EXPECT_EQ(size, oh.get().via.ext.size);
518 EXPECT_EQ(77, oh.get().via.ext.type());
519 EXPECT_TRUE(
520 std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
521
522 msgpack::sbuffer sbuf2;
523 msgpack::pack(sbuf2, oh.get());
524 msgpack::object_handle oh2 =
525 msgpack::unpack(sbuf2.data(), sbuf2.size());
526 EXPECT_EQ(size, oh2.get().via.ext.size);
527 EXPECT_EQ(77, oh2.get().via.ext.type());
528 EXPECT_TRUE(
529 std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
530
531 EXPECT_EQ(oh.get(), oh2.get());
532 }
533
TEST(MSGPACK,simple_buffer_fixext_2byte_65535)534 TEST(MSGPACK, simple_buffer_fixext_2byte_65535)
535 {
536 std::size_t const size = 65535;
537 msgpack::sbuffer sbuf;
538 msgpack::packer<msgpack::sbuffer> packer(sbuf);
539 char buf[size];
540 for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
541 packer.pack_ext(sizeof(buf), 77);
542 packer.pack_ext_body(buf, sizeof(buf));
543
544 msgpack::object_handle oh =
545 msgpack::unpack(sbuf.data(), sbuf.size());
546 EXPECT_EQ(size, oh.get().via.ext.size);
547 EXPECT_EQ(77, oh.get().via.ext.type());
548 EXPECT_TRUE(
549 std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
550
551 msgpack::sbuffer sbuf2;
552 msgpack::pack(sbuf2, oh.get());
553 msgpack::object_handle oh2 =
554 msgpack::unpack(sbuf2.data(), sbuf2.size());
555 EXPECT_EQ(size, oh2.get().via.ext.size);
556 EXPECT_EQ(77, oh2.get().via.ext.type());
557 EXPECT_TRUE(
558 std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
559
560 EXPECT_EQ(oh.get(), oh2.get());
561 }
562
TEST(MSGPACK,simple_buffer_fixext_4byte_65536)563 TEST(MSGPACK, simple_buffer_fixext_4byte_65536)
564 {
565 std::size_t const size = 65536;
566 msgpack::sbuffer sbuf;
567 msgpack::packer<msgpack::sbuffer> packer(sbuf);
568 char buf[size];
569 for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
570 packer.pack_ext(sizeof(buf), 77);
571 packer.pack_ext_body(buf, sizeof(buf));
572
573 msgpack::object_handle oh =
574 msgpack::unpack(sbuf.data(), sbuf.size());
575 EXPECT_EQ(size, oh.get().via.ext.size);
576 EXPECT_EQ(77, oh.get().via.ext.type());
577 EXPECT_TRUE(
578 std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
579
580 msgpack::sbuffer sbuf2;
581 msgpack::pack(sbuf2, oh.get());
582 msgpack::object_handle oh2 =
583 msgpack::unpack(sbuf2.data(), sbuf2.size());
584 EXPECT_EQ(size, oh2.get().via.ext.size);
585 EXPECT_EQ(77, oh2.get().via.ext.type());
586 EXPECT_TRUE(
587 std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
588
589 EXPECT_EQ(oh.get(), oh2.get());
590 }
591
TEST(MSGPACK,simple_buffer_ext_convert)592 TEST(MSGPACK, simple_buffer_ext_convert)
593 {
594 std::size_t const size = 65536;
595 msgpack::sbuffer sbuf;
596 msgpack::packer<msgpack::sbuffer> packer(sbuf);
597 char buf[size];
598 for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
599 packer.pack_ext(sizeof(buf), 77);
600 packer.pack_ext_body(buf, sizeof(buf));
601
602 msgpack::object_handle oh =
603 msgpack::unpack(sbuf.data(), sbuf.size());
604 msgpack::type::ext e;
605 oh.get().convert(e);
606 EXPECT_EQ(size, e.size());
607 EXPECT_EQ(77, e.type());
608 EXPECT_TRUE(
609 std::equal(buf, buf + sizeof(buf), e.data()));
610 }
611
TEST(MSGPACK,simple_buffer_ext_pack_convert)612 TEST(MSGPACK, simple_buffer_ext_pack_convert)
613 {
614 std::size_t const size = 65536;
615 msgpack::sbuffer sbuf;
616 msgpack::type::ext val1(77, size);
617 char* buf = val1.data();
618 for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
619 msgpack::pack(sbuf, val1);
620
621 msgpack::object_handle oh =
622 msgpack::unpack(sbuf.data(), sbuf.size());
623 msgpack::type::ext val2;
624 oh.get().convert(val2);
625 EXPECT_EQ(size, val2.size());
626 EXPECT_EQ(77, val2.type());
627 EXPECT_TRUE(
628 std::equal(buf, buf + sizeof(buf), val2.data()));
629 }
630
TEST(MSGPACK,simple_buffer_ext_ref_convert)631 TEST(MSGPACK, simple_buffer_ext_ref_convert)
632 {
633 std::size_t const size = 65536;
634 msgpack::sbuffer sbuf;
635 msgpack::packer<msgpack::sbuffer> packer(sbuf);
636 char buf[size];
637 for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
638 packer.pack_ext(sizeof(buf), 77);
639 packer.pack_ext_body(buf, sizeof(buf));
640
641 msgpack::object_handle oh =
642 msgpack::unpack(sbuf.data(), sbuf.size());
643 msgpack::type::ext_ref er;
644 oh.get().convert(er);
645 EXPECT_EQ(size, er.size());
646 EXPECT_EQ(77, er.type());
647 EXPECT_TRUE(
648 std::equal(buf, buf + sizeof(buf), er.data()));
649 }
650
TEST(MSGPACK,simple_buffer_ext_ref_pack_convert)651 TEST(MSGPACK, simple_buffer_ext_ref_pack_convert)
652 {
653 std::size_t const buf_size = 65536;
654 std::size_t const data_size = buf_size - 1;
655 msgpack::sbuffer sbuf;
656 char buf[buf_size];
657 buf[0] = static_cast<char>(77);
658 for (std::size_t i = 0; i != data_size; ++i) buf[i + 1] = static_cast<char>(i);
659 msgpack::pack(sbuf, msgpack::type::ext_ref(buf, buf_size));
660
661 msgpack::object_handle oh =
662 msgpack::unpack(sbuf.data(), sbuf.size());
663 msgpack::type::ext_ref val2;
664 oh.get().convert(val2);
665 EXPECT_EQ(data_size, val2.size());
666 EXPECT_EQ(77, val2.type());
667 EXPECT_TRUE(
668 std::equal(&buf[1], &buf[buf_size], val2.data()));
669 }
670
TEST(MSGPACK_STL,simple_buffer_string)671 TEST(MSGPACK_STL, simple_buffer_string)
672 {
673 for (unsigned int k = 0; k < kLoop; k++) {
674 string val1;
675 for (unsigned int i = 0; i < kElements; i++)
676 val1 += static_cast<char>('a' + rand() % 26);
677 msgpack::sbuffer sbuf;
678 msgpack::pack(sbuf, val1);
679 msgpack::object_handle oh =
680 msgpack::unpack(sbuf.data(), sbuf.size());
681 EXPECT_EQ(oh.get().type, msgpack::type::STR);
682 string val2 = oh.get().as<string>();
683 EXPECT_EQ(val1.size(), val2.size());
684 EXPECT_EQ(val1, val2);
685 }
686 }
687
TEST(MSGPACK_STL,simple_buffer_cstring)688 TEST(MSGPACK_STL, simple_buffer_cstring)
689 {
690 for (unsigned int k = 0; k < kLoop; k++) {
691 string val1;
692 for (unsigned int i = 0; i < kElements; i++)
693 val1 += static_cast<char>('a' + rand() % 26);
694 msgpack::sbuffer sbuf;
695 msgpack::pack(sbuf, val1.c_str());
696 msgpack::object_handle oh =
697 msgpack::unpack(sbuf.data(), sbuf.size());
698 EXPECT_EQ(oh.get().type, msgpack::type::STR);
699 string val2 = oh.get().as<string>();
700 EXPECT_EQ(val1.size(), val2.size());
701 EXPECT_EQ(val1, val2);
702 }
703 }
704
TEST(MSGPACK_STL,simple_buffer_non_const_cstring)705 TEST(MSGPACK_STL, simple_buffer_non_const_cstring)
706 {
707 for (unsigned int k = 0; k < kLoop; k++) {
708 string val1;
709 for (unsigned int i = 0; i < kElements; i++)
710 val1 += static_cast<char>('a' + rand() % 26);
711 msgpack::sbuffer sbuf;
712 char* s = new char[val1.size() + 1];
713 std::memcpy(s, val1.c_str(), val1.size() + 1);
714 msgpack::pack(sbuf, s);
715 delete [] s;
716 msgpack::object_handle oh =
717 msgpack::unpack(sbuf.data(), sbuf.size());
718 EXPECT_EQ(oh.get().type, msgpack::type::STR);
719 string val2 = oh.get().as<string>();
720 EXPECT_EQ(val1.size(), val2.size());
721 EXPECT_EQ(val1, val2);
722 }
723 }
724
TEST(MSGPACK_STL,simple_buffer_wstring)725 TEST(MSGPACK_STL, simple_buffer_wstring)
726 {
727 for (unsigned int k = 0; k < kLoop; k++) {
728 wstring val1;
729 for (unsigned int i = 0; i < kElements; i++)
730 val1 += L'a' + rand() % 26;
731 msgpack::sbuffer sbuf;
732 msgpack::pack(sbuf, val1);
733 msgpack::object_handle oh =
734 msgpack::unpack(sbuf.data(), sbuf.size());
735 EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
736 wstring val2 = oh.get().as<wstring>();
737 EXPECT_EQ(val1, val2);
738 wstring val3;
739 oh.get().convert(val3);
740 EXPECT_EQ(val1, val3);
741 }
742 }
743