1 | //===- MsgPackWriterTest.cpp ------------------------------------*- C++ -*-===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | #include "llvm/BinaryFormat/MsgPackWriter.h" |
10 | #include "llvm/BinaryFormat/MsgPack.h" |
11 | #include "gtest/gtest.h" |
12 | |
13 | using namespace llvm; |
14 | using namespace llvm::msgpack; |
15 | |
16 | struct MsgPackWriter : testing::Test { |
17 | std::string Buffer; |
18 | llvm::raw_string_ostream OStream; |
19 | Writer MPWriter; |
20 | |
21 | MsgPackWriter() : OStream(Buffer), MPWriter(OStream) {} |
22 | }; |
23 | |
24 | TEST_F(MsgPackWriter, TestWriteNil) { |
25 | MPWriter.writeNil(); |
26 | EXPECT_EQ(OStream.str(), "\xc0" ); |
27 | } |
28 | |
29 | TEST_F(MsgPackWriter, TestWriteBool) { |
30 | MPWriter.write(b: true); |
31 | MPWriter.write(b: false); |
32 | EXPECT_EQ(OStream.str(), "\xc3\xc2" ); |
33 | } |
34 | |
35 | TEST_F(MsgPackWriter, TestWriteFixPositiveInt) { |
36 | // FixPositiveInt form bitpattern starts with 0, so max FixPositiveInt |
37 | // is 01111111 = 127 |
38 | for (uint64_t u = 0; u <= 127; ++u) { |
39 | Buffer.clear(); |
40 | MPWriter.write(u); |
41 | std::string Output = OStream.str(); |
42 | EXPECT_EQ(Output.size(), 1u); |
43 | EXPECT_EQ(Output.data()[0], static_cast<uint8_t>(u)); |
44 | } |
45 | } |
46 | |
47 | TEST_F(MsgPackWriter, TestWriteUInt8Min) { |
48 | // See TestWriteFixPositiveInt for why 128 is the min non-fix Int8 |
49 | uint64_t u = 128; |
50 | MPWriter.write(u); |
51 | EXPECT_EQ(OStream.str(), "\xcc\x80" ); |
52 | } |
53 | |
54 | TEST_F(MsgPackWriter, TestWriteUInt8) { |
55 | uint64_t u = 221; |
56 | MPWriter.write(u); |
57 | EXPECT_EQ(OStream.str(), "\xcc\xdd" ); |
58 | } |
59 | |
60 | TEST_F(MsgPackWriter, TestWriteUInt8Max) { |
61 | uint64_t u = UINT8_MAX; |
62 | MPWriter.write(u); |
63 | EXPECT_EQ(OStream.str(), "\xcc\xff" ); |
64 | } |
65 | |
66 | TEST_F(MsgPackWriter, TestWriteUInt16Min) { |
67 | uint64_t u = static_cast<uint64_t>(UINT8_MAX) + 1; |
68 | MPWriter.write(u); |
69 | EXPECT_EQ(OStream.str(), std::string("\xcd\x01\x00" , 3)); |
70 | } |
71 | |
72 | TEST_F(MsgPackWriter, TestWriteUInt16) { |
73 | uint64_t u = 43981; |
74 | MPWriter.write(u); |
75 | EXPECT_EQ(OStream.str(), "\xcd\xab\xcd" ); |
76 | } |
77 | |
78 | TEST_F(MsgPackWriter, TestWriteUInt16Max) { |
79 | uint64_t u = UINT16_MAX; |
80 | MPWriter.write(u); |
81 | EXPECT_EQ(OStream.str(), "\xcd\xff\xff" ); |
82 | } |
83 | |
84 | TEST_F(MsgPackWriter, TestWriteUInt32Min) { |
85 | uint64_t u = static_cast<uint64_t>(UINT16_MAX) + 1; |
86 | MPWriter.write(u); |
87 | EXPECT_EQ(OStream.str(), std::string("\xce\x00\x01\x00\x00" , 5)); |
88 | } |
89 | |
90 | TEST_F(MsgPackWriter, TestWriteUInt32) { |
91 | uint64_t u = 2882400186; |
92 | MPWriter.write(u); |
93 | EXPECT_EQ(OStream.str(), "\xce\xab\xcd\xef\xba" ); |
94 | } |
95 | |
96 | TEST_F(MsgPackWriter, TestWriteUInt32Max) { |
97 | uint64_t u = UINT32_MAX; |
98 | MPWriter.write(u); |
99 | EXPECT_EQ(OStream.str(), "\xce\xff\xff\xff\xff" ); |
100 | } |
101 | |
102 | TEST_F(MsgPackWriter, TestWriteUInt64Min) { |
103 | uint64_t u = static_cast<uint64_t>(UINT32_MAX) + 1; |
104 | MPWriter.write(u); |
105 | EXPECT_EQ(OStream.str(), |
106 | std::string("\xcf\x00\x00\x00\x01\x00\x00\x00\x00" , 9)); |
107 | } |
108 | |
109 | TEST_F(MsgPackWriter, TestWriteUInt64) { |
110 | uint64_t u = 0x010203040506074a; |
111 | MPWriter.write(u); |
112 | EXPECT_EQ(OStream.str(), "\xcf\x01\x02\x03\x04\x05\x06\x07\x4a" ); |
113 | } |
114 | |
115 | TEST_F(MsgPackWriter, TestWriteUInt64Max) { |
116 | uint64_t u = UINT64_MAX; |
117 | MPWriter.write(u); |
118 | EXPECT_EQ(OStream.str(), "\xcf\xff\xff\xff\xff\xff\xff\xff\xff" ); |
119 | } |
120 | |
121 | TEST_F(MsgPackWriter, TestWriteFixNegativeInt) { |
122 | // Positive values will be written in a UInt form, so max FixNegativeInt is -1 |
123 | // |
124 | // FixNegativeInt form bitpattern starts with 111, so min FixNegativeInt |
125 | // is 11100000 = -32 |
126 | for (int64_t i = -1; i >= -32; --i) { |
127 | Buffer.clear(); |
128 | MPWriter.write(i); |
129 | std::string Output = OStream.str(); |
130 | EXPECT_EQ(Output.size(), 1u); |
131 | EXPECT_EQ(static_cast<int8_t>(Output.data()[0]), static_cast<int8_t>(i)); |
132 | } |
133 | } |
134 | |
135 | TEST_F(MsgPackWriter, TestWriteInt8Max) { |
136 | // See TestWriteFixNegativeInt for why -33 is the max non-fix Int8 |
137 | int64_t i = -33; |
138 | MPWriter.write(i); |
139 | EXPECT_EQ(OStream.str(), "\xd0\xdf" ); |
140 | } |
141 | |
142 | TEST_F(MsgPackWriter, TestWriteInt8) { |
143 | int64_t i = -40; |
144 | MPWriter.write(i); |
145 | EXPECT_EQ(OStream.str(), "\xd0\xd8" ); |
146 | } |
147 | |
148 | TEST_F(MsgPackWriter, TestWriteInt8Min) { |
149 | int64_t i = INT8_MIN; |
150 | MPWriter.write(i); |
151 | EXPECT_EQ(OStream.str(), "\xd0\x80" ); |
152 | } |
153 | |
154 | TEST_F(MsgPackWriter, TestWriteInt16Max) { |
155 | int64_t i = static_cast<int64_t>(INT8_MIN) - 1; |
156 | MPWriter.write(i); |
157 | EXPECT_EQ(OStream.str(), "\xd1\xff\x7f" ); |
158 | } |
159 | |
160 | TEST_F(MsgPackWriter, TestWriteInt16) { |
161 | int64_t i = -4369; |
162 | MPWriter.write(i); |
163 | EXPECT_EQ(OStream.str(), "\xd1\xee\xef" ); |
164 | } |
165 | |
166 | TEST_F(MsgPackWriter, TestWriteInt16Min) { |
167 | int64_t i = INT16_MIN; |
168 | MPWriter.write(i); |
169 | EXPECT_EQ(OStream.str(), std::string("\xd1\x80\x00" , 3)); |
170 | } |
171 | |
172 | TEST_F(MsgPackWriter, TestWriteInt32Max) { |
173 | int64_t i = static_cast<int64_t>(INT16_MIN) - 1; |
174 | MPWriter.write(i); |
175 | EXPECT_EQ(OStream.str(), "\xd2\xff\xff\x7f\xff" ); |
176 | } |
177 | |
178 | TEST_F(MsgPackWriter, TestWriteInt32) { |
179 | int64_t i = -286331153; |
180 | MPWriter.write(i); |
181 | EXPECT_EQ(OStream.str(), "\xd2\xee\xee\xee\xef" ); |
182 | } |
183 | |
184 | TEST_F(MsgPackWriter, TestWriteInt32Min) { |
185 | int64_t i = INT32_MIN; |
186 | MPWriter.write(i); |
187 | EXPECT_EQ(OStream.str(), std::string("\xd2\x80\x00\x00\x00" , 5)); |
188 | } |
189 | |
190 | TEST_F(MsgPackWriter, TestWriteInt64Max) { |
191 | int64_t i = static_cast<int64_t>(INT32_MIN) - 1; |
192 | MPWriter.write(i); |
193 | EXPECT_EQ(OStream.str(), "\xd3\xff\xff\xff\xff\x7f\xff\xff\xff" ); |
194 | } |
195 | |
196 | TEST_F(MsgPackWriter, TestWriteInt64) { |
197 | int64_t i = -1229782938247303441; |
198 | MPWriter.write(i); |
199 | EXPECT_EQ(OStream.str(), "\xd3\xee\xee\xee\xee\xee\xee\xee\xef" ); |
200 | } |
201 | |
202 | TEST_F(MsgPackWriter, TestWriteInt64Min) { |
203 | int64_t i = INT64_MIN; |
204 | MPWriter.write(i); |
205 | EXPECT_EQ(OStream.str(), |
206 | std::string("\xd3\x80\x00\x00\x00\x00\x00\x00\x00" , 9)); |
207 | } |
208 | |
209 | TEST_F(MsgPackWriter, TestWriteFloat32) { |
210 | float f = -3.6973142664068907e+28; |
211 | MPWriter.write(d: f); |
212 | EXPECT_EQ(OStream.str(), "\xca\xee\xee\xee\xef" ); |
213 | } |
214 | |
215 | TEST_F(MsgPackWriter, TestWriteFloat64) { |
216 | double d = -2.2899894549927042e+226; |
217 | MPWriter.write(d); |
218 | EXPECT_EQ(OStream.str(), "\xcb\xee\xee\xee\xee\xee\xee\xee\xef" ); |
219 | } |
220 | |
221 | TEST_F(MsgPackWriter, TestWriteFixStrMin) { |
222 | std::string s; |
223 | MPWriter.write(s); |
224 | EXPECT_EQ(OStream.str(), "\xa0" ); |
225 | } |
226 | |
227 | TEST_F(MsgPackWriter, TestWriteFixStr) { |
228 | std::string s = "foo" ; |
229 | MPWriter.write(s); |
230 | EXPECT_EQ(OStream.str(), "\xa3" |
231 | "foo" ); |
232 | } |
233 | |
234 | TEST_F(MsgPackWriter, TestWriteFixStrMax) { |
235 | // FixStr format's size is a 5 bit unsigned integer, so max is 11111 = 31 |
236 | std::string s(31, 'a'); |
237 | MPWriter.write(s); |
238 | EXPECT_EQ(OStream.str(), std::string("\xbf" ) + s); |
239 | } |
240 | |
241 | TEST_F(MsgPackWriter, TestWriteStr8Min) { |
242 | // See TestWriteFixStrMax for why 32 is the min non-fix Str8 |
243 | std::string s(32, 'a'); |
244 | MPWriter.write(s); |
245 | EXPECT_EQ(OStream.str(), std::string("\xd9\x20" ) + s); |
246 | } |
247 | |
248 | TEST_F(MsgPackWriter, TestWriteStr8) { |
249 | std::string s(33, 'a'); |
250 | MPWriter.write(s); |
251 | EXPECT_EQ(OStream.str(), std::string("\xd9\x21" ) + s); |
252 | } |
253 | |
254 | TEST_F(MsgPackWriter, TestWriteStr8Max) { |
255 | std::string s(UINT8_MAX, 'a'); |
256 | MPWriter.write(s); |
257 | EXPECT_EQ(OStream.str(), std::string("\xd9\xff" ) + s); |
258 | } |
259 | |
260 | TEST_F(MsgPackWriter, TestWriteStr16Min) { |
261 | std::string s(static_cast<uint64_t>(UINT8_MAX) + 1, 'a'); |
262 | MPWriter.write(s); |
263 | EXPECT_EQ(OStream.str(), std::string("\xda\x01\x00" , 3) + s); |
264 | } |
265 | |
266 | TEST_F(MsgPackWriter, TestWriteStr16) { |
267 | std::string s(511, 'a'); |
268 | MPWriter.write(s); |
269 | EXPECT_EQ(OStream.str(), std::string("\xda\x01\xff" ) + s); |
270 | } |
271 | |
272 | TEST_F(MsgPackWriter, TestWriteStr16Max) { |
273 | std::string s(UINT16_MAX, 'a'); |
274 | MPWriter.write(s); |
275 | EXPECT_EQ(OStream.str(), std::string("\xda\xff\xff" ) + s); |
276 | } |
277 | |
278 | TEST_F(MsgPackWriter, TestWriteStr32Min) { |
279 | std::string s(static_cast<uint64_t>(UINT16_MAX) + 1, 'a'); |
280 | MPWriter.write(s); |
281 | EXPECT_EQ(OStream.str(), std::string("\xdb\x00\x01\x00\x00" , 5) + s); |
282 | } |
283 | |
284 | TEST_F(MsgPackWriter, TestWriteStr32) { |
285 | std::string s(131071, 'a'); |
286 | MPWriter.write(s); |
287 | EXPECT_EQ(OStream.str(), std::string("\xdb\x00\x01\xff\xff" , 5) + s); |
288 | } |
289 | |
290 | TEST_F(MsgPackWriter, TestWriteBin8Min) { |
291 | std::string s; |
292 | MPWriter.write(Buffer: MemoryBufferRef(s, "" )); |
293 | EXPECT_EQ(OStream.str(), std::string("\xc4\x00" , 2) + s); |
294 | } |
295 | |
296 | TEST_F(MsgPackWriter, TestWriteBin8) { |
297 | std::string s(5, 'a'); |
298 | MPWriter.write(Buffer: MemoryBufferRef(s, "" )); |
299 | EXPECT_EQ(OStream.str(), std::string("\xc4\x05" ) + s); |
300 | } |
301 | |
302 | TEST_F(MsgPackWriter, TestWriteBin8Max) { |
303 | std::string s(UINT8_MAX, 'a'); |
304 | MPWriter.write(Buffer: MemoryBufferRef(s, "" )); |
305 | EXPECT_EQ(OStream.str(), std::string("\xc4\xff" ) + s); |
306 | } |
307 | |
308 | TEST_F(MsgPackWriter, TestWriteBin16Min) { |
309 | std::string s(static_cast<uint64_t>(UINT8_MAX) + 1, 'a'); |
310 | MPWriter.write(Buffer: MemoryBufferRef(s, "" )); |
311 | EXPECT_EQ(OStream.str(), std::string("\xc5\x01\x00" , 3) + s); |
312 | } |
313 | |
314 | TEST_F(MsgPackWriter, TestWriteBin16) { |
315 | std::string s(511, 'a'); |
316 | MPWriter.write(Buffer: MemoryBufferRef(s, "" )); |
317 | EXPECT_EQ(OStream.str(), "\xc5\x01\xff" + s); |
318 | } |
319 | |
320 | TEST_F(MsgPackWriter, TestWriteBin16Max) { |
321 | std::string s(UINT16_MAX, 'a'); |
322 | MPWriter.write(Buffer: MemoryBufferRef(s, "" )); |
323 | EXPECT_EQ(OStream.str(), std::string("\xc5\xff\xff" ) + s); |
324 | } |
325 | |
326 | TEST_F(MsgPackWriter, TestWriteBin32Min) { |
327 | std::string s(static_cast<uint64_t>(UINT16_MAX) + 1, 'a'); |
328 | MPWriter.write(Buffer: MemoryBufferRef(s, "" )); |
329 | EXPECT_EQ(OStream.str(), std::string("\xc6\x00\x01\x00\x00" , 5) + s); |
330 | } |
331 | |
332 | TEST_F(MsgPackWriter, TestWriteBin32) { |
333 | std::string s(131071, 'a'); |
334 | MPWriter.write(Buffer: MemoryBufferRef(s, "" )); |
335 | EXPECT_EQ(OStream.str(), std::string("\xc6\x00\x01\xff\xff" , 5) + s); |
336 | } |
337 | |
338 | TEST_F(MsgPackWriter, TestWriteFixArrayMin) { |
339 | MPWriter.writeArraySize(Size: 0); |
340 | EXPECT_EQ(OStream.str(), "\x90" ); |
341 | } |
342 | |
343 | TEST_F(MsgPackWriter, TestWriteFixArray) { |
344 | MPWriter.writeArraySize(Size: 4); |
345 | EXPECT_EQ(OStream.str(), "\x94" ); |
346 | } |
347 | |
348 | TEST_F(MsgPackWriter, TestWriteFixArrayMax) { |
349 | // FixArray format's size is a 4 bit unsigned integer, so max is 1111 = 15 |
350 | MPWriter.writeArraySize(Size: 15); |
351 | EXPECT_EQ(OStream.str(), "\x9f" ); |
352 | } |
353 | |
354 | TEST_F(MsgPackWriter, TestWriteArray16Min) { |
355 | // See TestWriteFixArrayMax for why 16 is the min non-fix Array16 |
356 | MPWriter.writeArraySize(Size: 16); |
357 | EXPECT_EQ(OStream.str(), std::string("\xdc\x00\x10" , 3)); |
358 | } |
359 | |
360 | TEST_F(MsgPackWriter, TestWriteArray16) { |
361 | MPWriter.writeArraySize(Size: 273); |
362 | EXPECT_EQ(OStream.str(), "\xdc\x01\x11" ); |
363 | } |
364 | |
365 | TEST_F(MsgPackWriter, TestWriteArray16Max) { |
366 | MPWriter.writeArraySize(UINT16_MAX); |
367 | EXPECT_EQ(OStream.str(), "\xdc\xff\xff" ); |
368 | } |
369 | |
370 | TEST_F(MsgPackWriter, TestWriteArray32Min) { |
371 | MPWriter.writeArraySize(Size: static_cast<uint64_t>(UINT16_MAX) + 1); |
372 | EXPECT_EQ(OStream.str(), std::string("\xdd\x00\x01\x00\x00" , 5)); |
373 | } |
374 | |
375 | TEST_F(MsgPackWriter, TestWriteArray32) { |
376 | MPWriter.writeArraySize(Size: 131071); |
377 | EXPECT_EQ(OStream.str(), std::string("\xdd\x00\x01\xff\xff" , 5)); |
378 | } |
379 | |
380 | TEST_F(MsgPackWriter, TestWriteArray32Max) { |
381 | MPWriter.writeArraySize(UINT32_MAX); |
382 | EXPECT_EQ(OStream.str(), "\xdd\xff\xff\xff\xff" ); |
383 | } |
384 | |
385 | TEST_F(MsgPackWriter, TestWriteFixMapMin) { |
386 | MPWriter.writeMapSize(Size: 0); |
387 | EXPECT_EQ(OStream.str(), "\x80" ); |
388 | } |
389 | |
390 | TEST_F(MsgPackWriter, TestWriteFixMap) { |
391 | MPWriter.writeMapSize(Size: 4); |
392 | EXPECT_EQ(OStream.str(), "\x84" ); |
393 | } |
394 | |
395 | TEST_F(MsgPackWriter, TestWriteFixMapMax) { |
396 | // FixMap format's size is a 4 bit unsigned integer, so max is 1111 = 15 |
397 | MPWriter.writeMapSize(Size: 15); |
398 | EXPECT_EQ(OStream.str(), "\x8f" ); |
399 | } |
400 | |
401 | TEST_F(MsgPackWriter, TestWriteMap16Min) { |
402 | // See TestWriteFixMapMax for why 16 is the min non-fix Map16 |
403 | MPWriter.writeMapSize(Size: 16); |
404 | EXPECT_EQ(OStream.str(), std::string("\xde\x00\x10" , 3)); |
405 | } |
406 | |
407 | TEST_F(MsgPackWriter, TestWriteMap16) { |
408 | MPWriter.writeMapSize(Size: 273); |
409 | EXPECT_EQ(OStream.str(), "\xde\x01\x11" ); |
410 | } |
411 | |
412 | TEST_F(MsgPackWriter, TestWriteMap16Max) { |
413 | MPWriter.writeMapSize(UINT16_MAX); |
414 | EXPECT_EQ(OStream.str(), "\xde\xff\xff" ); |
415 | } |
416 | |
417 | TEST_F(MsgPackWriter, TestWriteMap32Min) { |
418 | MPWriter.writeMapSize(Size: static_cast<uint64_t>(UINT16_MAX) + 1); |
419 | EXPECT_EQ(OStream.str(), std::string("\xdf\x00\x01\x00\x00" , 5)); |
420 | } |
421 | |
422 | TEST_F(MsgPackWriter, TestWriteMap32) { |
423 | MPWriter.writeMapSize(Size: 131071); |
424 | EXPECT_EQ(OStream.str(), std::string("\xdf\x00\x01\xff\xff" , 5)); |
425 | } |
426 | |
427 | TEST_F(MsgPackWriter, TestWriteMap32Max) { |
428 | MPWriter.writeMapSize(UINT32_MAX); |
429 | EXPECT_EQ(OStream.str(), std::string("\xdf\xff\xff\xff\xff" , 5)); |
430 | } |
431 | |
432 | // FixExt formats are only available for these specific lengths: 1, 2, 4, 8, 16 |
433 | |
434 | TEST_F(MsgPackWriter, TestWriteFixExt1) { |
435 | std::string s(1, 'a'); |
436 | MPWriter.writeExt(Type: 0x01, Buffer: MemoryBufferRef(s, "" )); |
437 | EXPECT_EQ(OStream.str(), std::string("\xd4\x01" ) + s); |
438 | } |
439 | |
440 | TEST_F(MsgPackWriter, TestWriteFixExt2) { |
441 | std::string s(2, 'a'); |
442 | MPWriter.writeExt(Type: 0x01, Buffer: MemoryBufferRef(s, "" )); |
443 | EXPECT_EQ(OStream.str(), std::string("\xd5\x01" ) + s); |
444 | } |
445 | |
446 | TEST_F(MsgPackWriter, TestWriteFixExt4) { |
447 | std::string s(4, 'a'); |
448 | MPWriter.writeExt(Type: 0x01, Buffer: MemoryBufferRef(s, "" )); |
449 | EXPECT_EQ(OStream.str(), std::string("\xd6\x01" ) + s); |
450 | } |
451 | |
452 | TEST_F(MsgPackWriter, TestWriteFixExt8) { |
453 | std::string s(8, 'a'); |
454 | MPWriter.writeExt(Type: 0x01, Buffer: MemoryBufferRef(s, "" )); |
455 | EXPECT_EQ(OStream.str(), std::string("\xd7\x01" ) + s); |
456 | } |
457 | |
458 | TEST_F(MsgPackWriter, TestWriteFixExt16) { |
459 | std::string s(16, 'a'); |
460 | MPWriter.writeExt(Type: 0x01, Buffer: MemoryBufferRef(s, "" )); |
461 | EXPECT_EQ(OStream.str(), std::string("\xd8\x01" ) + s); |
462 | } |
463 | |
464 | TEST_F(MsgPackWriter, TestWriteExt8Min) { |
465 | std::string s; |
466 | MPWriter.writeExt(Type: 0x01, Buffer: MemoryBufferRef(s, "" )); |
467 | EXPECT_EQ(OStream.str(), std::string("\xc7\x00\x01" , 3) + s); |
468 | } |
469 | |
470 | TEST_F(MsgPackWriter, TestWriteExt8) { |
471 | std::string s(0x2a, 'a'); |
472 | MPWriter.writeExt(Type: 0x01, Buffer: MemoryBufferRef(s, "" )); |
473 | EXPECT_EQ(OStream.str(), std::string("\xc7\x2a\x01" ) + s); |
474 | } |
475 | |
476 | TEST_F(MsgPackWriter, TestWriteExt8Max) { |
477 | std::string s(UINT8_MAX, 'a'); |
478 | MPWriter.writeExt(Type: 0x01, Buffer: MemoryBufferRef(s, "" )); |
479 | EXPECT_EQ(OStream.str(), std::string("\xc7\xff\x01" ) + s); |
480 | } |
481 | |
482 | TEST_F(MsgPackWriter, TestWriteExt16Min) { |
483 | std::string s(static_cast<uint16_t>(UINT8_MAX) + 1, 'a'); |
484 | MPWriter.writeExt(Type: 0x02, Buffer: MemoryBufferRef(s, "" )); |
485 | EXPECT_EQ(OStream.str(), std::string("\xc8\x01\x00\x02" , 4) + s); |
486 | } |
487 | |
488 | TEST_F(MsgPackWriter, TestWriteExt16) { |
489 | std::string s(273, 'a'); |
490 | MPWriter.writeExt(Type: 0x01, Buffer: MemoryBufferRef(s, "" )); |
491 | EXPECT_EQ(OStream.str(), std::string("\xc8\x01\x11\x01" ) + s); |
492 | } |
493 | |
494 | TEST_F(MsgPackWriter, TestWriteExt16Max) { |
495 | std::string s(UINT16_MAX, 'a'); |
496 | MPWriter.writeExt(Type: 0x01, Buffer: MemoryBufferRef(s, "" )); |
497 | EXPECT_EQ(OStream.str(), std::string("\xc8\xff\xff\x01" ) + s); |
498 | } |
499 | |
500 | TEST_F(MsgPackWriter, TestWriteExt32Min) { |
501 | std::string s(static_cast<uint32_t>(UINT16_MAX) + 1, 'a'); |
502 | MPWriter.writeExt(Type: 0x02, Buffer: MemoryBufferRef(s, "" )); |
503 | EXPECT_EQ(OStream.str(), std::string("\xc9\x00\x01\x00\x00\x02" , 6) + s); |
504 | } |
505 | |
506 | TEST_F(MsgPackWriter, TestWriteCompatibleNoStr8) { |
507 | Writer CompatWriter(OStream, true); |
508 | std::string s(32, 'a'); |
509 | CompatWriter.write(s); |
510 | EXPECT_EQ(OStream.str(), std::string("\xda\x00\x20" , 3) + s); |
511 | } |
512 | |
513 | TEST_F(MsgPackWriter, TestWriteCompatibleNoBin) { |
514 | Writer CompatWriter(OStream, true); |
515 | std::string s; |
516 | |
517 | #ifdef GTEST_HAS_DEATH_TEST |
518 | #ifndef NDEBUG |
519 | EXPECT_DEATH(CompatWriter.write(MemoryBufferRef(s, "" )), "compatible mode" ); |
520 | #endif |
521 | #endif |
522 | } |
523 | |