1 #include "msgpack.h"
2
3 #include <math.h>
4 #include <vector>
5 #include <limits>
6
7 #include <gtest/gtest.h>
8
9 using namespace std;
10
11 const unsigned int kLoop = 10000;
12 const double kEPS = 1e-10;
13
14 #define GEN_TEST_SIGNED(test_type, func_type) \
15 do { \
16 vector<test_type> v; \
17 v.push_back(0); \
18 v.push_back(1); \
19 v.push_back(-1); \
20 v.push_back(numeric_limits<test_type>::min()); \
21 v.push_back(numeric_limits<test_type>::max()); \
22 for (unsigned int i = 0; i < kLoop; i++) \
23 v.push_back(rand()); \
24 for (unsigned int i = 0; i < v.size() ; i++) { \
25 test_type val = v[i]; \
26 msgpack_sbuffer sbuf; \
27 msgpack_sbuffer_init(&sbuf); \
28 msgpack_packer pk; \
29 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); \
30 msgpack_pack_##func_type(&pk, val); \
31 msgpack_zone z; \
32 msgpack_zone_init(&z, 2048); \
33 msgpack_object obj; \
34 msgpack_unpack_return ret = \
35 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); \
36 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); \
37 if (val < 0) { \
38 EXPECT_EQ(MSGPACK_OBJECT_NEGATIVE_INTEGER, obj.type); \
39 EXPECT_EQ(val, obj.via.i64); \
40 } else { \
41 EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); \
42 EXPECT_EQ(val, obj.via.u64); \
43 } \
44 msgpack_zone_destroy(&z); \
45 msgpack_sbuffer_destroy(&sbuf); \
46 } \
47 } while(0)
48
49 #define GEN_TEST_UNSIGNED(test_type, func_type) \
50 do { \
51 vector<test_type> v; \
52 v.push_back(0); \
53 v.push_back(1); \
54 v.push_back(2); \
55 v.push_back(numeric_limits<test_type>::min()); \
56 v.push_back(numeric_limits<test_type>::max()); \
57 for (unsigned int i = 0; i < kLoop; i++) \
58 v.push_back(rand()); \
59 for (unsigned int i = 0; i < v.size() ; i++) { \
60 test_type val = v[i]; \
61 msgpack_sbuffer sbuf; \
62 msgpack_sbuffer_init(&sbuf); \
63 msgpack_packer pk; \
64 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); \
65 msgpack_pack_##func_type(&pk, val); \
66 msgpack_zone z; \
67 msgpack_zone_init(&z, 2048); \
68 msgpack_object obj; \
69 msgpack_unpack_return ret = \
70 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); \
71 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); \
72 EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); \
73 EXPECT_EQ(val, obj.via.u64); \
74 msgpack_zone_destroy(&z); \
75 msgpack_sbuffer_destroy(&sbuf); \
76 } \
77 } while(0)
78
TEST(MSGPACKC,simple_buffer_short)79 TEST(MSGPACKC, simple_buffer_short)
80 {
81 GEN_TEST_SIGNED(short, short);
82 }
83
TEST(MSGPACKC,simple_buffer_int)84 TEST(MSGPACKC, simple_buffer_int)
85 {
86 GEN_TEST_SIGNED(int, int);
87 }
88
TEST(MSGPACKC,simple_buffer_long)89 TEST(MSGPACKC, simple_buffer_long)
90 {
91 GEN_TEST_SIGNED(long, long);
92 }
93
TEST(MSGPACKC,simple_buffer_long_long)94 TEST(MSGPACKC, simple_buffer_long_long)
95 {
96 GEN_TEST_SIGNED(long long, long_long);
97 }
98
TEST(MSGPACKC,simple_buffer_unsigned_short)99 TEST(MSGPACKC, simple_buffer_unsigned_short)
100 {
101 GEN_TEST_UNSIGNED(unsigned short, unsigned_short);
102 }
103
TEST(MSGPACKC,simple_buffer_unsigned_int)104 TEST(MSGPACKC, simple_buffer_unsigned_int)
105 {
106 GEN_TEST_UNSIGNED(unsigned int, unsigned_int);
107 }
108
TEST(MSGPACKC,simple_buffer_unsigned_long)109 TEST(MSGPACKC, simple_buffer_unsigned_long)
110 {
111 GEN_TEST_UNSIGNED(unsigned long, unsigned_long);
112 }
113
TEST(MSGPACKC,simple_buffer_unsigned_long_long)114 TEST(MSGPACKC, simple_buffer_unsigned_long_long)
115 {
116 GEN_TEST_UNSIGNED(unsigned long long, unsigned_long_long);
117 }
118
TEST(MSGPACKC,simple_buffer_uint8)119 TEST(MSGPACKC, simple_buffer_uint8)
120 {
121 GEN_TEST_UNSIGNED(uint8_t, uint8);
122 }
123
TEST(MSGPACKC,simple_buffer_uint16)124 TEST(MSGPACKC, simple_buffer_uint16)
125 {
126 GEN_TEST_UNSIGNED(uint16_t, uint16);
127 }
128
TEST(MSGPACKC,simple_buffer_uint32)129 TEST(MSGPACKC, simple_buffer_uint32)
130 {
131 GEN_TEST_UNSIGNED(uint32_t, uint32);
132 }
133
TEST(MSGPACKC,simple_buffer_uint64)134 TEST(MSGPACKC, simple_buffer_uint64)
135 {
136 GEN_TEST_UNSIGNED(uint64_t, uint64);
137 }
138
TEST(MSGPACKC,simple_buffer_int8)139 TEST(MSGPACKC, simple_buffer_int8)
140 {
141 GEN_TEST_SIGNED(int8_t, int8);
142 }
143
TEST(MSGPACKC,simple_buffer_int16)144 TEST(MSGPACKC, simple_buffer_int16)
145 {
146 GEN_TEST_SIGNED(int16_t, int16);
147 }
148
TEST(MSGPACKC,simple_buffer_int32)149 TEST(MSGPACKC, simple_buffer_int32)
150 {
151 GEN_TEST_SIGNED(int32_t, int32);
152 }
153
TEST(MSGPACKC,simple_buffer_int64)154 TEST(MSGPACKC, simple_buffer_int64)
155 {
156 GEN_TEST_SIGNED(int64_t, int64);
157 }
158
TEST(MSGPACKC,simple_buffer_float)159 TEST(MSGPACKC, simple_buffer_float)
160 {
161 vector<float> v;
162 v.push_back(0.0);
163 v.push_back(1.0);
164 v.push_back(-1.0);
165 v.push_back(numeric_limits<float>::min());
166 v.push_back(numeric_limits<float>::max());
167 v.push_back(nanf("tag"));
168 v.push_back(1.0/0.0); // inf
169 v.push_back(-(1.0/0.0)); // -inf
170 for (unsigned int i = 0; i < kLoop; i++) {
171 v.push_back(drand48());
172 v.push_back(-drand48());
173 }
174
175 for (unsigned int i = 0; i < v.size() ; i++) {
176 float val = v[i];
177 msgpack_sbuffer sbuf;
178 msgpack_sbuffer_init(&sbuf);
179 msgpack_packer pk;
180 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
181 msgpack_pack_float(&pk, val);
182 msgpack_zone z;
183 msgpack_zone_init(&z, 2048);
184 msgpack_object obj;
185 msgpack_unpack_return ret =
186 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
187 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
188 EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, obj.type);
189 if (isnan(val))
190 EXPECT_TRUE(isnan(obj.via.dec));
191 else if (isinf(val))
192 EXPECT_TRUE(isinf(obj.via.dec));
193 else
194 EXPECT_TRUE(fabs(obj.via.dec - val) <= kEPS);
195 msgpack_zone_destroy(&z);
196 msgpack_sbuffer_destroy(&sbuf);
197 }
198 }
199
TEST(MSGPACKC,simple_buffer_double)200 TEST(MSGPACKC, simple_buffer_double)
201 {
202 vector<double> v;
203 v.push_back(0.0);
204 v.push_back(-0.0);
205 v.push_back(1.0);
206 v.push_back(-1.0);
207 v.push_back(numeric_limits<double>::min());
208 v.push_back(numeric_limits<double>::max());
209 v.push_back(nan("tag"));
210 v.push_back(1.0/0.0); // inf
211 v.push_back(-(1.0/0.0)); // -inf
212 for (unsigned int i = 0; i < kLoop; i++) {
213 v.push_back(drand48());
214 v.push_back(-drand48());
215 }
216
217 for (unsigned int i = 0; i < v.size() ; i++) {
218 double val = v[i];
219 msgpack_sbuffer sbuf;
220 msgpack_sbuffer_init(&sbuf);
221 msgpack_packer pk;
222 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
223 msgpack_pack_double(&pk, val);
224 msgpack_zone z;
225 msgpack_zone_init(&z, 2048);
226 msgpack_object obj;
227 msgpack_unpack_return ret =
228 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
229 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
230 EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, obj.type);
231 if (isnan(val))
232 EXPECT_TRUE(isnan(obj.via.dec));
233 else if (isinf(val))
234 EXPECT_TRUE(isinf(obj.via.dec));
235 else
236 EXPECT_TRUE(fabs(obj.via.dec - val) <= kEPS);
237 msgpack_zone_destroy(&z);
238 msgpack_sbuffer_destroy(&sbuf);
239 }
240 }
241
TEST(MSGPACKC,simple_buffer_nil)242 TEST(MSGPACKC, simple_buffer_nil)
243 {
244 msgpack_sbuffer sbuf;
245 msgpack_sbuffer_init(&sbuf);
246 msgpack_packer pk;
247 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
248 msgpack_pack_nil(&pk);
249 msgpack_zone z;
250 msgpack_zone_init(&z, 2048);
251 msgpack_object obj;
252 msgpack_unpack_return ret =
253 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
254 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
255 EXPECT_EQ(MSGPACK_OBJECT_NIL, obj.type);
256 msgpack_zone_destroy(&z);
257 msgpack_sbuffer_destroy(&sbuf);
258 }
259
TEST(MSGPACKC,simple_buffer_true)260 TEST(MSGPACKC, simple_buffer_true)
261 {
262 msgpack_sbuffer sbuf;
263 msgpack_sbuffer_init(&sbuf);
264 msgpack_packer pk;
265 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
266 msgpack_pack_true(&pk);
267 msgpack_zone z;
268 msgpack_zone_init(&z, 2048);
269 msgpack_object obj;
270 msgpack_unpack_return ret =
271 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
272 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
273 EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, obj.type);
274 EXPECT_EQ(true, obj.via.boolean);
275 msgpack_zone_destroy(&z);
276 msgpack_sbuffer_destroy(&sbuf);
277 }
278
TEST(MSGPACKC,simple_buffer_false)279 TEST(MSGPACKC, simple_buffer_false)
280 {
281 msgpack_sbuffer sbuf;
282 msgpack_sbuffer_init(&sbuf);
283 msgpack_packer pk;
284 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
285 msgpack_pack_false(&pk);
286 msgpack_zone z;
287 msgpack_zone_init(&z, 2048);
288 msgpack_object obj;
289 msgpack_unpack_return ret =
290 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
291 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
292 EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, obj.type);
293 EXPECT_EQ(false, obj.via.boolean);
294 msgpack_zone_destroy(&z);
295 msgpack_sbuffer_destroy(&sbuf);
296 }
297
TEST(MSGPACKC,simple_buffer_array)298 TEST(MSGPACKC, simple_buffer_array)
299 {
300 unsigned int array_size = 5;
301
302 msgpack_sbuffer sbuf;
303 msgpack_sbuffer_init(&sbuf);
304 msgpack_packer pk;
305 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
306 msgpack_pack_array(&pk, array_size);
307 msgpack_pack_nil(&pk);
308 msgpack_pack_true(&pk);
309 msgpack_pack_false(&pk);
310 msgpack_pack_int(&pk, 10);
311 msgpack_pack_int(&pk, -10);
312
313 msgpack_zone z;
314 msgpack_zone_init(&z, 2048);
315 msgpack_object obj;
316 msgpack_unpack_return ret;
317 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
318 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
319 EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type);
320 EXPECT_EQ(array_size, obj.via.array.size);
321
322 for (unsigned int i = 0; i < obj.via.array.size; i++) {
323 msgpack_object o = obj.via.array.ptr[i];
324 switch (i) {
325 case 0:
326 EXPECT_EQ(MSGPACK_OBJECT_NIL, o.type);
327 break;
328 case 1:
329 EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, o.type);
330 EXPECT_EQ(true, o.via.boolean);
331 break;
332 case 2:
333 EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, o.type);
334 EXPECT_EQ(false, o.via.boolean);
335 break;
336 case 3:
337 EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, o.type);
338 EXPECT_EQ(10, o.via.u64);
339 break;
340 case 4:
341 EXPECT_EQ(MSGPACK_OBJECT_NEGATIVE_INTEGER, o.type);
342 EXPECT_EQ(-10, o.via.i64);
343 break;
344 }
345 }
346
347 msgpack_zone_destroy(&z);
348 msgpack_sbuffer_destroy(&sbuf);
349 }
350
TEST(MSGPACKC,simple_buffer_map)351 TEST(MSGPACKC, simple_buffer_map)
352 {
353 unsigned int map_size = 2;
354
355 msgpack_sbuffer sbuf;
356 msgpack_sbuffer_init(&sbuf);
357 msgpack_packer pk;
358 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
359 msgpack_pack_map(&pk, map_size);
360 msgpack_pack_true(&pk);
361 msgpack_pack_false(&pk);
362 msgpack_pack_int(&pk, 10);
363 msgpack_pack_int(&pk, -10);
364
365 msgpack_zone z;
366 msgpack_zone_init(&z, 2048);
367 msgpack_object obj;
368 msgpack_unpack_return ret;
369 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
370 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
371 EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type);
372 EXPECT_EQ(map_size, obj.via.map.size);
373
374 for (unsigned int i = 0; i < map_size; i++) {
375 msgpack_object key = obj.via.map.ptr[i].key;
376 msgpack_object val = obj.via.map.ptr[i].val;
377 switch (i) {
378 case 0:
379 EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, key.type);
380 EXPECT_EQ(true, key.via.boolean);
381 EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, val.type);
382 EXPECT_EQ(false, val.via.boolean);
383 break;
384 case 1:
385 EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, key.type);
386 EXPECT_EQ(10, key.via.u64);
387 EXPECT_EQ(MSGPACK_OBJECT_NEGATIVE_INTEGER, val.type);
388 EXPECT_EQ(-10, val.via.i64);
389 break;
390 }
391 }
392
393 msgpack_zone_destroy(&z);
394 msgpack_sbuffer_destroy(&sbuf);
395 }
396
TEST(MSGPACKC,simple_buffer_raw)397 TEST(MSGPACKC, simple_buffer_raw)
398 {
399 unsigned int raw_size = 7;
400
401 msgpack_sbuffer sbuf;
402 msgpack_sbuffer_init(&sbuf);
403 msgpack_packer pk;
404 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
405 msgpack_pack_raw(&pk, raw_size);
406 msgpack_pack_raw_body(&pk, "fr", 2);
407 msgpack_pack_raw_body(&pk, "syuki", 5);
408 // invalid data
409 msgpack_pack_raw_body(&pk, "", 0);
410 msgpack_pack_raw_body(&pk, "kzk", 0);
411
412 msgpack_zone z;
413 msgpack_zone_init(&z, 2048);
414 msgpack_object obj;
415 msgpack_unpack_return ret;
416 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
417 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
418 EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type);
419 EXPECT_EQ(raw_size, obj.via.raw.size);
420 EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size));
421
422 msgpack_zone_destroy(&z);
423 msgpack_sbuffer_destroy(&sbuf);
424 }
425