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