1 /* gcc boundary.c -o boundary -Wconversion -Wpointer-sign */
2 #include <msgpack.h>
3 #include <stdio.h>
4 #include <assert.h>
5
atohex(char a)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
bytesncmp(char * data,const char * bytes,size_t len)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
main()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 }
297