Skip to content

Commit d7d5be4

Browse files
ygj6ygj6
committed
examples of packing boundary values
1 parent 102dba8 commit d7d5be4

File tree

2 files changed

+297
-0
lines changed

2 files changed

+297
-0
lines changed

‎example/c/CMakeLists.txt‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
LIST (APPEND exec_PROGRAMS
2+
boundary.c
23
lib_buffer_unpack.c
34
simple_c.c
45
speed_test_uint32_array.c

‎example/c/boundary.c‎

Lines changed: 296 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,296 @@
1+
/* gcc boundary.c -o boundary -Wconversion -Wpointer-sign */
2+
#include <msgpack.h>
3+
#include <stdio.h>
4+
#include <assert.h>
5+
6+
static inline unsigned char atohex(char a)
7+
{
8+
int x;
9+
if (a >= 'a') {
10+
x = a - 'a' + 10;
11+
} else if (a >= 'A') {
12+
x = a - 'A' + 10;
13+
} else {
14+
x = a - '0';
15+
}
16+
assert(x >= 0 && x < 16);
17+
return (unsigned char)x;
18+
}
19+
20+
// Return 0 if equal
21+
static inline int bytesncmp(char *data, const char *bytes, size_t len)
22+
{
23+
size_t n = len >> 1;
24+
size_t i = 0;
25+
int diff;
26+
for (; i < n; i++) {
27+
diff = (unsigned char)data[i] - (atohex(bytes[2 * i]) << 4) - atohex(bytes[2 * i + 1]);
28+
if (diff != 0) {
29+
return diff;
30+
}
31+
}
32+
return 0;
33+
}
34+
35+
int main()
36+
{
37+
msgpack_sbuffer sbuf;
38+
msgpack_packer *x;
39+
size_t offset = 0;
40+
char data[65536];
41+
msgpack_timestamp ts[] = {
42+
{ 0xFFFFFFFF, 0 },
43+
{ 0x100000000, 0 },
44+
{ 0x3FFFFFFFF, 0 },
45+
{ 0x400000000, 0 },
46+
{ INT64_MAX, UINT32_MAX }
47+
};
48+
49+
#define check_sbuffer(b) \
50+
do { \
51+
size_t len = strlen(#b); \
52+
assert((sbuf.size - offset) * 2 == len); \
53+
assert(bytesncmp(sbuf.data + offset, #b, len) == 0); \
54+
offset = sbuf.size; \
55+
} while (0)
56+
57+
msgpack_sbuffer_init(&sbuf);
58+
x = msgpack_packer_new(&sbuf, msgpack_sbuffer_write);
59+
60+
msgpack_pack_fix_uint8(x, 0); check_sbuffer(cc00); /* cc 00 */
61+
msgpack_pack_fix_uint8(x, 0xFF); check_sbuffer(ccff); /* cc ff */
62+
msgpack_pack_fix_uint16(x, 0); check_sbuffer(cd0000); /* cd 00 00 */
63+
msgpack_pack_fix_uint16(x, 0xFFFF); check_sbuffer(cdffff); /* cd ff ff */
64+
msgpack_pack_fix_uint32(x, 0); check_sbuffer(ce00000000); /* ce 00 00 00 00 */
65+
msgpack_pack_fix_uint32(x, 0xFFFFFFFF); check_sbuffer(ceffffffff); /* ce ff ff ff ff */
66+
msgpack_pack_fix_uint64(x, 0); check_sbuffer(cf0000000000000000); /* cf 00 00 00 00 00 00 00 00 */
67+
msgpack_pack_fix_uint64(x, 0xFFFFFFFFFFFFFFFF); check_sbuffer(cfffffffffffffffff); /* cf ff ff ff ff ff ff ff ff */
68+
69+
msgpack_pack_uint8(x, 0); check_sbuffer(00); /* 00 */
70+
msgpack_pack_uint8(x, 0x7F); check_sbuffer(7f); /* 7f */
71+
msgpack_pack_uint8(x, 0x80); check_sbuffer(cc80); /* cc 80 */
72+
msgpack_pack_uint8(x, 0xFF); check_sbuffer(ccff); /* cc ff */
73+
74+
msgpack_pack_uint16(x, 0); check_sbuffer(00); /* 00 */
75+
msgpack_pack_uint16(x, 0x7F); check_sbuffer(7f); /* 7f */
76+
msgpack_pack_uint16(x, 0x80); check_sbuffer(cc80); /* cc 80 */
77+
msgpack_pack_uint16(x, 0xFF); check_sbuffer(ccff); /* cc ff */
78+
msgpack_pack_uint16(x, 0x100); check_sbuffer(cd0100); /* cd 01 00 */
79+
msgpack_pack_uint16(x, 0xFFFF); check_sbuffer(cdffff); /* cd ff ff */
80+
81+
msgpack_pack_uint32(x, 0); check_sbuffer(00); /* 00 */
82+
msgpack_pack_uint32(x, 0x7F); check_sbuffer(7f); /* 7f */
83+
msgpack_pack_uint32(x, 0x80); check_sbuffer(cc80); /* cc 80 */
84+
msgpack_pack_uint32(x, 0xFF); check_sbuffer(ccff); /* cc ff */
85+
msgpack_pack_uint32(x, 0x100); check_sbuffer(cd0100); /* cd 01 00 */
86+
msgpack_pack_uint32(x, 0xFFFF); check_sbuffer(cdffff); /* cd ff ff */
87+
msgpack_pack_uint32(x, 0x10000); check_sbuffer(ce00010000); /* ce 00 01 00 00 */
88+
msgpack_pack_uint32(x, 0xFFFFFFFF); check_sbuffer(ceffffffff); /* ce ff ff ff ff */
89+
90+
msgpack_pack_uint64(x, 0); check_sbuffer(00); /* 00 */
91+
msgpack_pack_uint64(x, 0x7F); check_sbuffer(7f); /* 7f */
92+
msgpack_pack_uint64(x, 0x80); check_sbuffer(cc80); /* cc 80 */
93+
msgpack_pack_uint64(x, 0xFF); check_sbuffer(ccff); /* cc ff */
94+
msgpack_pack_uint64(x, 0x100); check_sbuffer(cd0100); /* cd 01 00 */
95+
msgpack_pack_uint64(x, 0xFFFF); check_sbuffer(cdffff); /* cd ff ff */
96+
msgpack_pack_uint64(x, 0x10000); check_sbuffer(ce00010000); /* ce 00 01 00 00 */
97+
msgpack_pack_uint64(x, 0xFFFFFFFF); check_sbuffer(ceffffffff); /* ce ff ff ff ff */
98+
msgpack_pack_uint64(x, 0x100000000); check_sbuffer(cf0000000100000000); /* cf 00 00 00 01 00 00 00 00 */
99+
msgpack_pack_uint64(x, 0xFFFFFFFFFFFFFFFF); check_sbuffer(cfffffffffffffffff); /* cf ff ff ff ff ff ff ff ff */
100+
101+
msgpack_pack_fix_int8(x, 0x7F); check_sbuffer(d07f); /* d0 7f */
102+
msgpack_pack_fix_int8(x, -0x7F-1); check_sbuffer(d080); /* d0 80 */
103+
msgpack_pack_fix_int16(x, 0x7FFF); check_sbuffer(d17fff); /* d1 7f ff */
104+
msgpack_pack_fix_int16(x, -0x7FFF-1); check_sbuffer(d18000); /* d1 80 00 */
105+
msgpack_pack_fix_int32(x, 0x7FFFFFFF); check_sbuffer(d27fffffff); /* d2 7f ff ff ff */
106+
msgpack_pack_fix_int32(x, -0x7FFFFFFF-1); check_sbuffer(d280000000); /* d2 80 00 00 00 */
107+
msgpack_pack_fix_int64(x, 0x7FFFFFFFFFFFFFFF); check_sbuffer(d37fffffffffffffff); /* d3 7f ff ff ff ff ff ff ff */
108+
msgpack_pack_fix_int64(x, -0x7FFFFFFFFFFFFFFF-1); check_sbuffer(d38000000000000000); /* d3 80 00 00 00 00 00 00 00 */
109+
110+
msgpack_pack_int8(x, -0x7F-1); check_sbuffer(d080); /* d0 80 */
111+
msgpack_pack_int8(x, -0x21); check_sbuffer(d0df); /* d0 df */
112+
msgpack_pack_int8(x, -0x20); check_sbuffer(e0); /* e0 */
113+
msgpack_pack_int8(x, -1); check_sbuffer(ff); /* ff */
114+
msgpack_pack_int8(x, 0); check_sbuffer(00); /* 00 */
115+
msgpack_pack_int8(x, 0x7F); check_sbuffer(7f); /* 7f */
116+
117+
msgpack_pack_int16(x, -0x7FFF-1); check_sbuffer(d18000); /* d1 80 00 */
118+
msgpack_pack_int16(x, -0x81); check_sbuffer(d1ff7f); /* d1 ff 7f */
119+
msgpack_pack_int16(x, -0x80); check_sbuffer(d080); /* d0 80 */
120+
msgpack_pack_int16(x, -0x21); check_sbuffer(d0df); /* d0 df */
121+
msgpack_pack_int16(x, -0x20); check_sbuffer(e0); /* e0 */
122+
msgpack_pack_int16(x, -0x1); check_sbuffer(ff); /* ff */
123+
msgpack_pack_int16(x, 0); check_sbuffer(00); /* 00 */
124+
msgpack_pack_int16(x, 0x7F); check_sbuffer(7f); /* 7f */
125+
msgpack_pack_int16(x, 0x80); check_sbuffer(cc80); /* cc 80 */
126+
msgpack_pack_int16(x, 0xFF); check_sbuffer(ccff); /* cc ff */
127+
msgpack_pack_int16(x, 0x100); check_sbuffer(cd0100); /* cd 01 00 */
128+
msgpack_pack_int16(x, 0x7FFF); check_sbuffer(cd7fff); /* cd 7f ff */
129+
130+
msgpack_pack_int32(x, -0x7FFFFFFF-1); check_sbuffer(d280000000); /* d2 80 00 00 00 */
131+
msgpack_pack_int32(x, -0x8001); check_sbuffer(d2ffff7fff); /* d2 ff ff 7f ff */
132+
msgpack_pack_int32(x, -0x8000); check_sbuffer(d18000); /* d1 80 00 */
133+
msgpack_pack_int32(x, -0x81); check_sbuffer(d1ff7f); /* d1 ff 7f */
134+
msgpack_pack_int32(x, -0x80); check_sbuffer(d080); /* d0 80 */
135+
msgpack_pack_int32(x, -0x21); check_sbuffer(d0df); /* d0 df */
136+
msgpack_pack_int32(x, -0x20); check_sbuffer(e0); /* e0 */
137+
msgpack_pack_int32(x, -0x1); check_sbuffer(ff); /* ff */
138+
msgpack_pack_int32(x, 0); check_sbuffer(00); /* 00 */
139+
msgpack_pack_int32(x, 0x7F); check_sbuffer(7f); /* 7f */
140+
msgpack_pack_int32(x, 0x80); check_sbuffer(cc80); /* cc 80 */
141+
msgpack_pack_int32(x, 0xFF); check_sbuffer(ccff); /* cc ff */
142+
msgpack_pack_int32(x, 0x100); check_sbuffer(cd0100); /* cd 01 00 */
143+
msgpack_pack_int32(x, 0xFFFF); check_sbuffer(cdffff); /* cd ff ff */
144+
msgpack_pack_int32(x, 0x10000); check_sbuffer(ce00010000); /* ce 00 01 00 00 */
145+
msgpack_pack_int32(x, 0x7FFFFFFF); check_sbuffer(ce7fffffff); /* ce 7f ff ff ff */
146+
147+
msgpack_pack_int64(x, -0x7FFFFFFFFFFFFFFF-1); check_sbuffer(d38000000000000000); /* d3 80 00 00 00 00 00 00 00 */
148+
msgpack_pack_int64(x, -((1LL<<31)+1)); check_sbuffer(d3ffffffff7fffffff); /* d3 ff ff ff ff 7f ff ff ff */
149+
msgpack_pack_int64(x, -(1LL<<31)); check_sbuffer(d280000000); /* d2 80 00 00 00 */
150+
msgpack_pack_int64(x, -0x8001); check_sbuffer(d2ffff7fff); /* d2 ff ff 7f ff */
151+
msgpack_pack_int64(x, -0x8000); check_sbuffer(d18000); /* d1 80 00 */
152+
msgpack_pack_int64(x, -0x81); check_sbuffer(d1ff7f); /* d1 ff 7f */
153+
msgpack_pack_int64(x, -0x80); check_sbuffer(d080); /* d0 80 */
154+
msgpack_pack_int64(x, -0x21); check_sbuffer(d0df); /* d0 df */
155+
msgpack_pack_int64(x, -0x20); check_sbuffer(e0); /* e0 */
156+
msgpack_pack_int64(x, -0x1); check_sbuffer(ff); /* ff */
157+
msgpack_pack_int64(x, 0); check_sbuffer(00); /* 00 */
158+
msgpack_pack_int64(x, 0x7F); check_sbuffer(7f); /* 7f */
159+
msgpack_pack_int64(x, 0x80); check_sbuffer(cc80); /* cc 80 */
160+
msgpack_pack_int64(x, 0xFF); check_sbuffer(ccff); /* cc ff */
161+
msgpack_pack_int64(x, 0x100); check_sbuffer(cd0100); /* cd 01 00 */
162+
msgpack_pack_int64(x, 0xFFFF); check_sbuffer(cdffff); /* cd ff ff */
163+
msgpack_pack_int64(x, 0x10000); check_sbuffer(ce00010000); /* ce 00 01 00 00 */
164+
msgpack_pack_int64(x, 0xFFFFFFFF); check_sbuffer(ceffffffff); /* ce ff ff ff ff */
165+
msgpack_pack_int64(x, 0x100000000); check_sbuffer(cf0000000100000000); /* cf 00 00 00 01 00 00 00 00 */
166+
msgpack_pack_int64(x, 0x7FFFFFFFFFFFFFFF); check_sbuffer(cf7fffffffffffffff); /* cf 7f ff ff ff ff ff ff ff */
167+
168+
msgpack_pack_nil(x); check_sbuffer(c0); /* c0 */
169+
msgpack_pack_false(x); check_sbuffer(c2); /* c2 */
170+
msgpack_pack_true(x); check_sbuffer(c3); /* c3 */
171+
172+
msgpack_pack_float(x, 1.0); check_sbuffer(ca3f800000); /* ca 3f 80 00 00 */
173+
msgpack_pack_double(x, 1.0); check_sbuffer(cb3ff0000000000000); /* cb 3f f0 00 00 00 00 00 00 */
174+
175+
msgpack_pack_unsigned_char(x, UINT8_MAX); /* same as msgpack_pack_uint8() */
176+
msgpack_pack_unsigned_short(x, (unsigned short)UINT64_MAX);
177+
msgpack_pack_unsigned_int(x, (unsigned int)UINT64_MAX);
178+
msgpack_pack_unsigned_long(x, (unsigned long)UINT64_MAX);
179+
msgpack_pack_unsigned_long_long(x, (unsigned long long)UINT64_MAX);
180+
181+
msgpack_pack_signed_char(x, INT8_MAX); /* same as msgpack_pack_int8() */
182+
183+
#define check_sbuffer_n(b) \
184+
do { \
185+
size_t len = strlen(#b); \
186+
assert(bytesncmp(sbuf.data + offset, #b, len) == 0); \
187+
offset = sbuf.size; \
188+
} while (0)
189+
190+
#define fill_str(n) msgpack_pack_str_body(x, data, n)
191+
192+
offset = sbuf.size;
193+
msgpack_pack_str(x, 0); /* "" */ check_sbuffer(a0); /* a0 */
194+
msgpack_pack_str(x, 31);
195+
fill_str(31); check_sbuffer_n(bf); /* bf ... */
196+
msgpack_pack_str(x, 32);
197+
fill_str(32); check_sbuffer_n(d920); /* d9 20 ... */
198+
msgpack_pack_str(x, 255);
199+
fill_str(255); check_sbuffer_n(d9ff); /* d9 ff ... */
200+
msgpack_pack_str(x, 256);
201+
fill_str(256); check_sbuffer_n(da0100); /* da 01 00 ... */
202+
msgpack_pack_str(x, 65535);
203+
fill_str(65535); check_sbuffer_n(daffff); /* da ff ff ... */
204+
msgpack_pack_str(x, 65536);
205+
fill_str(65536); check_sbuffer_n(db00010000); /* db 00 01 00 00 ... */
206+
207+
#define fill_map(n) \
208+
do { \
209+
size_t i = 0; \
210+
for (; i < n * 2; i++) { msgpack_pack_int8(x, 0x1); } \
211+
} while (0);
212+
213+
msgpack_pack_map(x, 0); /* {} */ check_sbuffer(80); /* 80 */
214+
msgpack_pack_map(x, 1);
215+
fill_map(1); check_sbuffer_n(81); /* 81 ... */
216+
msgpack_pack_map(x, 15);
217+
fill_map(15); check_sbuffer_n(8f); /* 8f ... */
218+
msgpack_pack_map(x, 16);
219+
fill_map(16); check_sbuffer_n(de0010); /* de 00 10 ... */
220+
msgpack_pack_map(x, 65535);
221+
fill_map(65535); check_sbuffer_n(deffff); /* de ff ff ... */
222+
msgpack_pack_map(x, 65536);
223+
fill_map(65536); check_sbuffer_n(df00010000); /* df 00 01 00 00 ... */
224+
225+
#define fill_array(n) \
226+
do { \
227+
size_t i = 0; \
228+
for (; i < n; i++) { msgpack_pack_int8(x, 0x1); } \
229+
} while (0);
230+
231+
msgpack_pack_array(x, 0); /* [] */ check_sbuffer(90); /* 90 */
232+
msgpack_pack_array(x, 1);
233+
fill_array(1); check_sbuffer_n(91); /* 91 ... */
234+
msgpack_pack_array(x, 15);
235+
fill_array(15); check_sbuffer_n(9f); /* 9f ... */
236+
msgpack_pack_array(x, 16);
237+
fill_array(16); check_sbuffer_n(dc0010); /* dc 00 10 ... */
238+
msgpack_pack_array(x, 65535);
239+
fill_array(65535); check_sbuffer_n(dcffff); /* dc ff ff ... */
240+
msgpack_pack_array(x, 65536);
241+
fill_array(65536); check_sbuffer_n(dd00010000); /* dd 00 01 00 00 ... */
242+
243+
#define fill_bin(n) msgpack_pack_bin_body(x, data, n)
244+
245+
msgpack_pack_bin(x, 0); check_sbuffer(c400); /* c4 00 */
246+
msgpack_pack_bin(x, 1);
247+
fill_bin(1); check_sbuffer_n(c401); /* c4 01 ... */
248+
msgpack_pack_bin(x, 255);
249+
fill_bin(255); check_sbuffer_n(c4ff); /* c4 ff ... */
250+
msgpack_pack_bin(x, 256);
251+
fill_bin(256); check_sbuffer_n(c50100); /* c5 01 00 ... */
252+
msgpack_pack_bin(x, 65535);
253+
fill_bin(65535); check_sbuffer_n(c5ffff); /* c5 ff ff ... */
254+
msgpack_pack_bin(x, 65536);
255+
fill_bin(65536); check_sbuffer_n(c600010000); /* c6 00 01 00 00 ... */
256+
257+
#define fill_ext(n) msgpack_pack_ext_body(x, data, n)
258+
259+
msgpack_pack_ext(x, 1, 0x7F);
260+
fill_ext(1); check_sbuffer_n(d47f); /* d4 7f ... */
261+
msgpack_pack_ext(x, 2, 0x7F);
262+
fill_ext(2); check_sbuffer_n(d57f); /* d5 7f ... */
263+
msgpack_pack_ext(x, 4, 0x7F);
264+
fill_ext(4); check_sbuffer_n(d67f); /* d6 7f ... */
265+
msgpack_pack_ext(x, 8, 0x7F);
266+
fill_ext(8); check_sbuffer_n(d77f); /* d7 7f ... */
267+
msgpack_pack_ext(x, 16, 0x7F);
268+
fill_ext(16); check_sbuffer_n(d87f); /* d8 7f ... */
269+
270+
msgpack_pack_ext(x, 0, 0x7F); check_sbuffer(c7007f); /* c7 00 7f */
271+
msgpack_pack_ext(x, 3, 0x7F);
272+
fill_ext(3); check_sbuffer_n(c7037f); /* c7 03 7f */
273+
msgpack_pack_ext(x, 5, 0x7F);
274+
fill_ext(5); check_sbuffer_n(c7057f); /* c7 05 7f */
275+
msgpack_pack_ext(x, 17, 0x7F);
276+
fill_ext(17); check_sbuffer_n(c7117f); /* c7 11 7f */
277+
msgpack_pack_ext(x, 255, 0x7F);
278+
fill_ext(255); check_sbuffer_n(c7ff7f); /* c7 ff 7f ... */
279+
msgpack_pack_ext(x, 256, 0x7F);
280+
fill_ext(256); check_sbuffer_n(c801007f); /* c8 01 00 7f ... */
281+
msgpack_pack_ext(x, 65535, 0x7F);
282+
fill_ext(65535); check_sbuffer_n(c8ffff7f); /* c8 ff ff 7f ... */
283+
msgpack_pack_ext(x, 65536, 0x7F);
284+
fill_ext(65536); check_sbuffer_n(c9000100007f); /* c9 00 01 00 00 7f ... */
285+
286+
msgpack_pack_timestamp(x, ts); check_sbuffer(d6ffffffffff); /* d6 ff ff ff ff ff */
287+
msgpack_pack_timestamp(x, ts + 1); check_sbuffer(d7ff0000000100000000); /* d7 ff 00 00 00 01 00 00 00 00 */
288+
msgpack_pack_timestamp(x, ts + 2); check_sbuffer(d7ff00000003ffffffff); /* d7 ff 00 00 00 03 ff ff ff ff */
289+
msgpack_pack_timestamp(x, ts + 3); check_sbuffer(c70cff000000000000000400000000); /* c7 0c ff 00 00 00 00 00 00 00 04 00 00 00 00 */
290+
msgpack_pack_timestamp(x, ts + 4); check_sbuffer(c70cffffffffff7fffffffffffffff); /* c7 0c ff ff ff ff ff 7f ff ff ff ff ff ff ff */
291+
292+
msgpack_sbuffer_destroy(&sbuf);
293+
msgpack_packer_free(x);
294+
295+
return 0;
296+
}

0 commit comments

Comments
 (0)