1//===- MsgPackReaderTest.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/MsgPackReader.h"
10#include "llvm/BinaryFormat/MsgPack.h"
11#include "gtest/gtest.h"
12
13using namespace llvm;
14using namespace llvm::msgpack;
15
16struct MsgPackReader : testing::Test {
17 std::string Buffer;
18 Object Obj;
19};
20
21TEST_F(MsgPackReader, TestReadMultiple) {
22 Buffer = "\xc0\xc2";
23 Reader MPReader(Buffer);
24 {
25 auto ContinueOrErr = MPReader.read(Obj);
26 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
27 EXPECT_TRUE(*ContinueOrErr);
28 EXPECT_EQ(Obj.Kind, Type::Nil);
29 }
30 {
31 auto ContinueOrErr = MPReader.read(Obj);
32 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
33 EXPECT_TRUE(*ContinueOrErr);
34 EXPECT_EQ(Obj.Kind, Type::Boolean);
35 EXPECT_EQ(Obj.Bool, false);
36 }
37 {
38 auto ContinueOrErr = MPReader.read(Obj);
39 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
40 EXPECT_FALSE(*ContinueOrErr);
41 }
42}
43
44TEST_F(MsgPackReader, TestReadNil) {
45 Buffer = "\xc0";
46 Reader MPReader(Buffer);
47 auto ContinueOrErr = MPReader.read(Obj);
48 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
49 EXPECT_TRUE(*ContinueOrErr);
50 EXPECT_EQ(Obj.Kind, Type::Nil);
51}
52
53TEST_F(MsgPackReader, TestReadBoolFalse) {
54 Buffer = "\xc2";
55 Reader MPReader(Buffer);
56 auto ContinueOrErr = MPReader.read(Obj);
57 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
58 EXPECT_TRUE(*ContinueOrErr);
59 EXPECT_EQ(Obj.Kind, Type::Boolean);
60 EXPECT_EQ(Obj.Bool, false);
61}
62
63TEST_F(MsgPackReader, TestReadBoolTrue) {
64 Buffer = "\xc3";
65 Reader MPReader(Buffer);
66 auto ContinueOrErr = MPReader.read(Obj);
67 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
68 EXPECT_TRUE(*ContinueOrErr);
69 EXPECT_EQ(Obj.Kind, Type::Boolean);
70 EXPECT_EQ(Obj.Bool, true);
71}
72
73TEST_F(MsgPackReader, TestReadFixNegativeInt) {
74 // Positive values will be written in a UInt form, so max FixNegativeInt is -1
75 //
76 // FixNegativeInt form bitpattern starts with 111, so min FixNegativeInt
77 // is 11100000 = -32
78 for (int8_t i = -1; i >= -32; --i) {
79 Buffer.assign(n: 1, c: static_cast<char>(i));
80 Reader MPReader(Buffer);
81 auto ContinueOrErr = MPReader.read(Obj);
82 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
83 EXPECT_TRUE(*ContinueOrErr);
84 EXPECT_EQ(Obj.Kind, Type::Int);
85 EXPECT_EQ(Obj.Int, i);
86 }
87}
88
89TEST_F(MsgPackReader, TestReadInt8Max) {
90 Buffer = "\xd0\x7f";
91 Reader MPReader(Buffer);
92 auto ContinueOrErr = MPReader.read(Obj);
93 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
94 EXPECT_TRUE(*ContinueOrErr);
95 EXPECT_EQ(Obj.Kind, Type::Int);
96 EXPECT_EQ(Obj.Int, INT8_MAX);
97}
98
99TEST_F(MsgPackReader, TestReadInt8Zero) {
100 Buffer.assign(s: "\xd0\x00", n: 2);
101 Reader MPReader(Buffer);
102 auto ContinueOrErr = MPReader.read(Obj);
103 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
104 EXPECT_TRUE(*ContinueOrErr);
105 EXPECT_EQ(Obj.Kind, Type::Int);
106 EXPECT_EQ(Obj.Int, 0);
107}
108
109TEST_F(MsgPackReader, TestReadInt8Min) {
110 Buffer = "\xd0\x80";
111 Reader MPReader(Buffer);
112 auto ContinueOrErr = MPReader.read(Obj);
113 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
114 EXPECT_TRUE(*ContinueOrErr);
115 EXPECT_EQ(Obj.Kind, Type::Int);
116 EXPECT_EQ(Obj.Int, INT8_MIN);
117}
118
119TEST_F(MsgPackReader, TestReadInt16Max) {
120 Buffer = "\xd1\x7f\xff";
121 Reader MPReader(Buffer);
122 auto ContinueOrErr = MPReader.read(Obj);
123 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
124 EXPECT_TRUE(*ContinueOrErr);
125 EXPECT_EQ(Obj.Kind, Type::Int);
126 EXPECT_EQ(Obj.Int, INT16_MAX);
127}
128
129TEST_F(MsgPackReader, TestReadInt16Zero) {
130 Buffer.assign(s: "\xd1\x00\x00", n: 3);
131 Reader MPReader(Buffer);
132 auto ContinueOrErr = MPReader.read(Obj);
133 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
134 EXPECT_TRUE(*ContinueOrErr);
135 EXPECT_EQ(Obj.Kind, Type::Int);
136 EXPECT_EQ(Obj.Int, 0);
137}
138
139TEST_F(MsgPackReader, TestReadInt16Min) {
140 Buffer.assign(s: "\xd1\x80\x00", n: 3);
141 Reader MPReader(Buffer);
142 auto ContinueOrErr = MPReader.read(Obj);
143 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
144 EXPECT_TRUE(*ContinueOrErr);
145 EXPECT_EQ(Obj.Kind, Type::Int);
146 EXPECT_EQ(Obj.Int, INT16_MIN);
147}
148
149TEST_F(MsgPackReader, TestReadInt32Max) {
150 Buffer = "\xd2\x7f\xff\xff\xff";
151 Reader MPReader(Buffer);
152 auto ContinueOrErr = MPReader.read(Obj);
153 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
154 EXPECT_TRUE(*ContinueOrErr);
155 EXPECT_EQ(Obj.Kind, Type::Int);
156 EXPECT_EQ(Obj.Int, INT32_MAX);
157}
158
159TEST_F(MsgPackReader, TestReadInt32Zero) {
160 Buffer.assign(s: "\xd2\x00\x00\x00\x00", n: 5);
161 Reader MPReader(Buffer);
162 auto ContinueOrErr = MPReader.read(Obj);
163 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
164 EXPECT_TRUE(*ContinueOrErr);
165 EXPECT_EQ(Obj.Kind, Type::Int);
166 EXPECT_EQ(Obj.Int, 0);
167}
168
169TEST_F(MsgPackReader, TestReadInt32Min) {
170 Buffer.assign(s: "\xd2\x80\x00\x00\x00", n: 5);
171 Reader MPReader(Buffer);
172 auto ContinueOrErr = MPReader.read(Obj);
173 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
174 EXPECT_TRUE(*ContinueOrErr);
175 EXPECT_EQ(Obj.Kind, Type::Int);
176 EXPECT_EQ(Obj.Int, INT32_MIN);
177}
178
179TEST_F(MsgPackReader, TestReadInt64Max) {
180 Buffer = "\xd3\x7f\xff\xff\xff\xff\xff\xff\xff";
181 Reader MPReader(Buffer);
182 auto ContinueOrErr = MPReader.read(Obj);
183 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
184 EXPECT_TRUE(*ContinueOrErr);
185 EXPECT_EQ(Obj.Kind, Type::Int);
186 EXPECT_EQ(Obj.Int, INT64_MAX);
187}
188
189TEST_F(MsgPackReader, TestReadInt64Zero) {
190 Buffer.assign(s: "\xd3\x00\x00\x00\x00\x00\x00\x00\x00", n: 9);
191 Reader MPReader(Buffer);
192 auto ContinueOrErr = MPReader.read(Obj);
193 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
194 EXPECT_TRUE(*ContinueOrErr);
195 EXPECT_EQ(Obj.Kind, Type::Int);
196 EXPECT_EQ(Obj.Int, 0);
197}
198
199TEST_F(MsgPackReader, TestReadInt64Min) {
200 Buffer.assign(s: "\xd3\x80\x00\x00\x00\x00\x00\x00\x00", n: 9);
201 Reader MPReader(Buffer);
202 auto ContinueOrErr = MPReader.read(Obj);
203 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
204 EXPECT_TRUE(*ContinueOrErr);
205 EXPECT_EQ(Obj.Kind, Type::Int);
206 EXPECT_EQ(Obj.Int, INT64_MIN);
207}
208
209TEST_F(MsgPackReader, TestReadFixPositiveInt) {
210 // FixPositiveInt form bitpattern starts with 0, so max FixPositiveInt
211 // is 01111111 = 127
212 for (uint64_t u = 0; u <= 127; ++u) {
213 Buffer.assign(n: 1, c: static_cast<char>(u));
214 Reader MPReader(Buffer);
215 auto ContinueOrErr = MPReader.read(Obj);
216 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
217 EXPECT_TRUE(*ContinueOrErr);
218 EXPECT_EQ(Obj.Kind, Type::UInt);
219 EXPECT_EQ(Obj.UInt, u);
220 }
221}
222
223TEST_F(MsgPackReader, TestReadUInt8Zero) {
224 Buffer.assign(s: "\xcc\x00", n: 2);
225 Reader MPReader(Buffer);
226 auto ContinueOrErr = MPReader.read(Obj);
227 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
228 EXPECT_TRUE(*ContinueOrErr);
229 EXPECT_EQ(Obj.Kind, Type::UInt);
230 EXPECT_EQ(Obj.UInt, 0u);
231}
232
233TEST_F(MsgPackReader, TestReadUInt8One) {
234 Buffer = "\xcc\x01";
235 Reader MPReader(Buffer);
236 auto ContinueOrErr = MPReader.read(Obj);
237 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
238 EXPECT_TRUE(*ContinueOrErr);
239 EXPECT_EQ(Obj.Kind, Type::UInt);
240 EXPECT_EQ(Obj.UInt, 1u);
241}
242
243TEST_F(MsgPackReader, TestReadUInt8Max) {
244 Buffer = "\xcc\xff";
245 Reader MPReader(Buffer);
246 auto ContinueOrErr = MPReader.read(Obj);
247 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
248 EXPECT_TRUE(*ContinueOrErr);
249 EXPECT_EQ(Obj.Kind, Type::UInt);
250 EXPECT_EQ(Obj.UInt, static_cast<uint8_t>(UINT8_MAX));
251}
252
253TEST_F(MsgPackReader, TestReadUInt16Zero) {
254 Buffer.assign(s: "\xcd\x00\x00", n: 3);
255 Reader MPReader(Buffer);
256 auto ContinueOrErr = MPReader.read(Obj);
257 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
258 EXPECT_TRUE(*ContinueOrErr);
259 EXPECT_EQ(Obj.Kind, Type::UInt);
260 EXPECT_EQ(Obj.UInt, 0u);
261}
262
263TEST_F(MsgPackReader, TestReadUInt16One) {
264 Buffer.assign(s: "\xcd\x00\x01", n: 3);
265 Reader MPReader(Buffer);
266 auto ContinueOrErr = MPReader.read(Obj);
267 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
268 EXPECT_TRUE(*ContinueOrErr);
269 EXPECT_EQ(Obj.Kind, Type::UInt);
270 EXPECT_EQ(Obj.UInt, 1u);
271}
272
273TEST_F(MsgPackReader, TestReadUInt16Max) {
274 Buffer = "\xcd\xff\xff";
275 Reader MPReader(Buffer);
276 auto ContinueOrErr = MPReader.read(Obj);
277 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
278 EXPECT_TRUE(*ContinueOrErr);
279 EXPECT_EQ(Obj.Kind, Type::UInt);
280 EXPECT_EQ(Obj.UInt, static_cast<uint16_t>(UINT16_MAX));
281}
282
283TEST_F(MsgPackReader, TestReadUInt32Zero) {
284 Buffer.assign(s: "\xce\x00\x00\x00\x00", n: 5);
285 Reader MPReader(Buffer);
286 auto ContinueOrErr = MPReader.read(Obj);
287 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
288 EXPECT_TRUE(*ContinueOrErr);
289 EXPECT_EQ(Obj.Kind, Type::UInt);
290 EXPECT_EQ(Obj.UInt, 0u);
291}
292
293TEST_F(MsgPackReader, TestReadUInt32One) {
294 Buffer.assign(s: "\xce\x00\x00\x00\x01", n: 5);
295 Reader MPReader(Buffer);
296 auto ContinueOrErr = MPReader.read(Obj);
297 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
298 EXPECT_TRUE(*ContinueOrErr);
299 EXPECT_EQ(Obj.Kind, Type::UInt);
300 EXPECT_EQ(Obj.UInt, 1u);
301}
302
303TEST_F(MsgPackReader, TestReadUInt32Max) {
304 Buffer = "\xce\xff\xff\xff\xff";
305 Reader MPReader(Buffer);
306 auto ContinueOrErr = MPReader.read(Obj);
307 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
308 EXPECT_TRUE(*ContinueOrErr);
309 EXPECT_EQ(Obj.Kind, Type::UInt);
310 EXPECT_EQ(Obj.UInt, static_cast<uint32_t>(UINT32_MAX));
311}
312
313TEST_F(MsgPackReader, TestReadUInt64Zero) {
314 Buffer.assign(s: "\xcf\x00\x00\x00\x00\x00\x00\x00\x00", n: 9);
315 Reader MPReader(Buffer);
316 auto ContinueOrErr = MPReader.read(Obj);
317 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
318 EXPECT_TRUE(*ContinueOrErr);
319 EXPECT_EQ(Obj.Kind, Type::UInt);
320 EXPECT_EQ(Obj.UInt, 0u);
321}
322
323TEST_F(MsgPackReader, TestReadUInt64One) {
324 Buffer.assign(s: "\xcf\x00\x00\x00\x00\x00\x00\x00\x01", n: 9);
325 Reader MPReader(Buffer);
326 auto ContinueOrErr = MPReader.read(Obj);
327 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
328 EXPECT_TRUE(*ContinueOrErr);
329 EXPECT_EQ(Obj.Kind, Type::UInt);
330 EXPECT_EQ(Obj.UInt, 1u);
331}
332
333TEST_F(MsgPackReader, TestReadUInt64Max) {
334 Buffer = "\xcf\xff\xff\xff\xff\xff\xff\xff\xff";
335 Reader MPReader(Buffer);
336 auto ContinueOrErr = MPReader.read(Obj);
337 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
338 EXPECT_TRUE(*ContinueOrErr);
339 EXPECT_EQ(Obj.Kind, Type::UInt);
340 EXPECT_EQ(Obj.UInt, static_cast<uint64_t>(UINT64_MAX));
341}
342
343TEST_F(MsgPackReader, TestReadFloat32) {
344 Buffer = "\xca\xee\xee\xee\xef";
345 Reader MPReader(Buffer);
346 auto ContinueOrErr = MPReader.read(Obj);
347 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
348 EXPECT_TRUE(*ContinueOrErr);
349 EXPECT_EQ(Obj.Kind, Type::Float);
350 EXPECT_EQ(Obj.Float, -3.6973142664068907e+28f);
351}
352
353TEST_F(MsgPackReader, TestReadFloat64) {
354 Buffer = "\xcb\xee\xee\xee\xee\xee\xee\xee\xef";
355 Reader MPReader(Buffer);
356 auto ContinueOrErr = MPReader.read(Obj);
357 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
358 EXPECT_TRUE(*ContinueOrErr);
359 EXPECT_EQ(Obj.Kind, Type::Float);
360 EXPECT_EQ(Obj.Float, -2.2899894549927042e+226);
361}
362
363TEST_F(MsgPackReader, TestReadFixStrZero) {
364 Buffer = "\xa0";
365 Reader MPReader(Buffer);
366 auto ContinueOrErr = MPReader.read(Obj);
367 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
368 EXPECT_TRUE(*ContinueOrErr);
369 EXPECT_EQ(Obj.Kind, Type::String);
370 EXPECT_EQ(Obj.Raw, StringRef());
371}
372
373TEST_F(MsgPackReader, TestReadFixStrOne) {
374 std::string Result(1, 'a');
375 Buffer = std::string("\xa1") + Result;
376 Reader MPReader(Buffer);
377 auto ContinueOrErr = MPReader.read(Obj);
378 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
379 EXPECT_TRUE(*ContinueOrErr);
380 EXPECT_EQ(Obj.Kind, Type::String);
381 EXPECT_EQ(Obj.Raw, Result);
382}
383
384TEST_F(MsgPackReader, TestReadFixStrMax) {
385 // FixStr format's size is a 5 bit unsigned integer, so max is 11111 = 31
386 std::string Result(31, 'a');
387 Buffer = std::string("\xbf") + Result;
388 Reader MPReader(Buffer);
389 auto ContinueOrErr = MPReader.read(Obj);
390 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
391 EXPECT_TRUE(*ContinueOrErr);
392 EXPECT_EQ(Obj.Kind, Type::String);
393 EXPECT_EQ(Obj.Raw, Result);
394}
395
396TEST_F(MsgPackReader, TestReadStr8Zero) {
397 Buffer.assign(s: "\xd9\x00", n: 2);
398 Reader MPReader(Buffer);
399 auto ContinueOrErr = MPReader.read(Obj);
400 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
401 EXPECT_TRUE(*ContinueOrErr);
402 EXPECT_EQ(Obj.Kind, Type::String);
403 EXPECT_EQ(Obj.Raw, StringRef());
404}
405
406TEST_F(MsgPackReader, TestReadStr8One) {
407 std::string Result(1, 'a');
408 Buffer = std::string("\xd9\x01") + Result;
409 Reader MPReader(Buffer);
410 auto ContinueOrErr = MPReader.read(Obj);
411 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
412 EXPECT_TRUE(*ContinueOrErr);
413 EXPECT_EQ(Obj.Kind, Type::String);
414 EXPECT_EQ(Obj.Raw, Result);
415}
416
417TEST_F(MsgPackReader, TestReadStr8Max) {
418 std::string Result(UINT8_MAX, 'a');
419 Buffer = std::string("\xd9\xff") + Result;
420 Reader MPReader(Buffer);
421 auto ContinueOrErr = MPReader.read(Obj);
422 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
423 EXPECT_TRUE(*ContinueOrErr);
424 EXPECT_EQ(Obj.Kind, Type::String);
425 EXPECT_EQ(Obj.Raw, Result);
426}
427
428TEST_F(MsgPackReader, TestReadStr16Zero) {
429 Buffer.assign(s: "\xda\x00\x00", n: 3);
430 Reader MPReader(Buffer);
431 auto ContinueOrErr = MPReader.read(Obj);
432 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
433 EXPECT_TRUE(*ContinueOrErr);
434 EXPECT_EQ(Obj.Kind, Type::String);
435 EXPECT_EQ(Obj.Raw, StringRef());
436}
437
438TEST_F(MsgPackReader, TestReadStr16One) {
439 std::string Result(1, 'a');
440 Buffer = std::string("\xda\x00\x01", 3) + Result;
441 Reader MPReader(Buffer);
442 auto ContinueOrErr = MPReader.read(Obj);
443 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
444 EXPECT_TRUE(*ContinueOrErr);
445 EXPECT_EQ(Obj.Kind, Type::String);
446 EXPECT_EQ(Obj.Raw, Result);
447}
448
449TEST_F(MsgPackReader, TestReadStr16Max) {
450 std::string Result(UINT16_MAX, 'a');
451 Buffer = std::string("\xda\xff\xff") + Result;
452 Reader MPReader(Buffer);
453 auto ContinueOrErr = MPReader.read(Obj);
454 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
455 EXPECT_TRUE(*ContinueOrErr);
456 EXPECT_EQ(Obj.Kind, Type::String);
457 EXPECT_EQ(Obj.Raw, Result);
458}
459
460TEST_F(MsgPackReader, TestReadStr32Zero) {
461 Buffer.assign(s: "\xdb\x00\x00\x00\x00", n: 5);
462 Reader MPReader(Buffer);
463 auto ContinueOrErr = MPReader.read(Obj);
464 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
465 EXPECT_TRUE(*ContinueOrErr);
466 EXPECT_EQ(Obj.Kind, Type::String);
467 EXPECT_EQ(Obj.Raw, StringRef());
468}
469
470TEST_F(MsgPackReader, TestReadStr32One) {
471 std::string Result(1, 'a');
472 Buffer = std::string("\xdb\x00\x00\x00\x01", 5) + Result;
473 Reader MPReader(Buffer);
474 auto ContinueOrErr = MPReader.read(Obj);
475 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
476 EXPECT_TRUE(*ContinueOrErr);
477 EXPECT_EQ(Obj.Kind, Type::String);
478 EXPECT_EQ(Obj.Raw, Result);
479}
480
481TEST_F(MsgPackReader, TestReadStr32Max) {
482 std::string Result(static_cast<uint32_t>(UINT16_MAX) + 1, 'a');
483 Buffer = std::string("\xdb\x00\x01\x00\x00", 5) + Result;
484 Reader MPReader(Buffer);
485 auto ContinueOrErr = MPReader.read(Obj);
486 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
487 EXPECT_TRUE(*ContinueOrErr);
488 EXPECT_EQ(Obj.Kind, Type::String);
489 EXPECT_EQ(Obj.Raw, Result);
490}
491
492TEST_F(MsgPackReader, TestReadBin8Zero) {
493 Buffer.assign(s: "\xc4\x00", n: 2);
494 Reader MPReader(Buffer);
495 auto ContinueOrErr = MPReader.read(Obj);
496 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
497 EXPECT_TRUE(*ContinueOrErr);
498 EXPECT_EQ(Obj.Kind, Type::Binary);
499 EXPECT_EQ(Obj.Raw, StringRef());
500}
501
502TEST_F(MsgPackReader, TestReadBin8One) {
503 std::string Result(1, 'a');
504 Buffer = std::string("\xc4\x01") + Result;
505 Reader MPReader(Buffer);
506 auto ContinueOrErr = MPReader.read(Obj);
507 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
508 EXPECT_TRUE(*ContinueOrErr);
509 EXPECT_EQ(Obj.Kind, Type::Binary);
510 EXPECT_EQ(Obj.Raw, Result);
511}
512
513TEST_F(MsgPackReader, TestReadBin8Max) {
514 std::string Result(UINT8_MAX, 'a');
515 Buffer = std::string("\xc4\xff") + Result;
516 Reader MPReader(Buffer);
517 auto ContinueOrErr = MPReader.read(Obj);
518 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
519 EXPECT_TRUE(*ContinueOrErr);
520 EXPECT_EQ(Obj.Kind, Type::Binary);
521 EXPECT_EQ(Obj.Raw, Result);
522}
523
524TEST_F(MsgPackReader, TestReadBin16Zero) {
525 Buffer.assign(s: "\xc5\x00\x00", n: 3);
526 Reader MPReader(Buffer);
527 auto ContinueOrErr = MPReader.read(Obj);
528 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
529 EXPECT_TRUE(*ContinueOrErr);
530 EXPECT_EQ(Obj.Kind, Type::Binary);
531 EXPECT_EQ(Obj.Raw, StringRef());
532}
533
534TEST_F(MsgPackReader, TestReadBin16One) {
535 std::string Result(1, 'a');
536 Buffer = std::string("\xc5\x00\x01", 3) + Result;
537 Reader MPReader(Buffer);
538 auto ContinueOrErr = MPReader.read(Obj);
539 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
540 EXPECT_TRUE(*ContinueOrErr);
541 EXPECT_EQ(Obj.Kind, Type::Binary);
542 EXPECT_EQ(Obj.Raw, Result);
543}
544
545TEST_F(MsgPackReader, TestReadBin16Max) {
546 std::string Result(UINT16_MAX, 'a');
547 Buffer = std::string("\xc5\xff\xff") + Result;
548 Reader MPReader(Buffer);
549 auto ContinueOrErr = MPReader.read(Obj);
550 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
551 EXPECT_TRUE(*ContinueOrErr);
552 EXPECT_EQ(Obj.Kind, Type::Binary);
553 EXPECT_EQ(Obj.Raw, Result);
554}
555
556TEST_F(MsgPackReader, TestReadBin32Zero) {
557 Buffer.assign(s: "\xc6\x00\x00\x00\x00", n: 5);
558 Reader MPReader(Buffer);
559 auto ContinueOrErr = MPReader.read(Obj);
560 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
561 EXPECT_TRUE(*ContinueOrErr);
562 EXPECT_EQ(Obj.Kind, Type::Binary);
563 EXPECT_EQ(Obj.Raw, StringRef());
564}
565
566TEST_F(MsgPackReader, TestReadBin32One) {
567 std::string Result(1, 'a');
568 Buffer = std::string("\xc6\x00\x00\x00\x01", 5) + Result;
569 Reader MPReader(Buffer);
570 auto ContinueOrErr = MPReader.read(Obj);
571 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
572 EXPECT_TRUE(*ContinueOrErr);
573 EXPECT_EQ(Obj.Kind, Type::Binary);
574 EXPECT_EQ(Obj.Raw, Result);
575}
576
577TEST_F(MsgPackReader, TestReadBin32Max) {
578 std::string Result(static_cast<uint32_t>(UINT16_MAX) + 1, 'a');
579 Buffer = std::string("\xc6\x00\x01\x00\x00", 5) + Result;
580 Reader MPReader(Buffer);
581 auto ContinueOrErr = MPReader.read(Obj);
582 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
583 EXPECT_TRUE(*ContinueOrErr);
584 EXPECT_EQ(Obj.Kind, Type::Binary);
585 EXPECT_EQ(Obj.Raw, Result);
586}
587
588TEST_F(MsgPackReader, TestReadFixArrayZero) {
589 Buffer = "\x90";
590 Reader MPReader(Buffer);
591 auto ContinueOrErr = MPReader.read(Obj);
592 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
593 EXPECT_TRUE(*ContinueOrErr);
594 EXPECT_EQ(Obj.Kind, Type::Array);
595 EXPECT_EQ(Obj.Length, 0u);
596}
597
598TEST_F(MsgPackReader, TestReadFixArrayOne) {
599 Buffer = "\x91";
600 Reader MPReader(Buffer);
601 auto ContinueOrErr = MPReader.read(Obj);
602 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
603 EXPECT_TRUE(*ContinueOrErr);
604 EXPECT_EQ(Obj.Kind, Type::Array);
605 EXPECT_EQ(Obj.Length, 1u);
606}
607
608TEST_F(MsgPackReader, TestReadFixArrayMax) {
609 Buffer = "\x9f";
610 Reader MPReader(Buffer);
611 auto ContinueOrErr = MPReader.read(Obj);
612 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
613 EXPECT_TRUE(*ContinueOrErr);
614 EXPECT_EQ(Obj.Kind, Type::Array);
615 // FixArray format's size is a 4 bit unsigned integer, so max is 1111 = 15
616 EXPECT_EQ(Obj.Length, 15u);
617}
618
619TEST_F(MsgPackReader, TestReadArray16Zero) {
620 Buffer.assign(s: "\xdc\x00\x00", n: 3);
621 Reader MPReader(Buffer);
622 auto ContinueOrErr = MPReader.read(Obj);
623 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
624 EXPECT_TRUE(*ContinueOrErr);
625 EXPECT_EQ(Obj.Kind, Type::Array);
626 EXPECT_EQ(Obj.Length, 0u);
627}
628
629TEST_F(MsgPackReader, TestReadArray16One) {
630 Buffer.assign(s: "\xdc\x00\x01", n: 3);
631 Reader MPReader(Buffer);
632 auto ContinueOrErr = MPReader.read(Obj);
633 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
634 EXPECT_TRUE(*ContinueOrErr);
635 EXPECT_EQ(Obj.Kind, Type::Array);
636 EXPECT_EQ(Obj.Length, 1u);
637}
638
639TEST_F(MsgPackReader, TestReadArray16Max) {
640 Buffer = "\xdc\xff\xff";
641 Reader MPReader(Buffer);
642 auto ContinueOrErr = MPReader.read(Obj);
643 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
644 EXPECT_TRUE(*ContinueOrErr);
645 EXPECT_EQ(Obj.Kind, Type::Array);
646 EXPECT_EQ(Obj.Length, static_cast<uint16_t>(UINT16_MAX));
647}
648
649TEST_F(MsgPackReader, TestReadArray32Zero) {
650 Buffer.assign(s: "\xdd\x00\x00\x00\x00", n: 5);
651 Reader MPReader(Buffer);
652 auto ContinueOrErr = MPReader.read(Obj);
653 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
654 EXPECT_TRUE(*ContinueOrErr);
655 EXPECT_EQ(Obj.Kind, Type::Array);
656 EXPECT_EQ(Obj.Length, 0u);
657}
658
659TEST_F(MsgPackReader, TestReadArray32One) {
660 Buffer.assign(s: "\xdd\x00\x00\x00\x01", n: 5);
661 Reader MPReader(Buffer);
662 auto ContinueOrErr = MPReader.read(Obj);
663 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
664 EXPECT_TRUE(*ContinueOrErr);
665 EXPECT_EQ(Obj.Kind, Type::Array);
666 EXPECT_EQ(Obj.Length, 1u);
667}
668
669TEST_F(MsgPackReader, TestReadArray32Max) {
670 Buffer = "\xdd\xff\xff\xff\xff";
671 Reader MPReader(Buffer);
672 auto ContinueOrErr = MPReader.read(Obj);
673 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
674 EXPECT_TRUE(*ContinueOrErr);
675 EXPECT_EQ(Obj.Kind, Type::Array);
676 EXPECT_EQ(Obj.Length, static_cast<uint32_t>(UINT32_MAX));
677}
678
679TEST_F(MsgPackReader, TestReadFixMapZero) {
680 Buffer = "\x80";
681 Reader MPReader(Buffer);
682 auto ContinueOrErr = MPReader.read(Obj);
683 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
684 EXPECT_TRUE(*ContinueOrErr);
685 EXPECT_EQ(Obj.Kind, Type::Map);
686 EXPECT_EQ(Obj.Length, 0u);
687}
688
689TEST_F(MsgPackReader, TestReadFixMapOne) {
690 Buffer = "\x81";
691 Reader MPReader(Buffer);
692 auto ContinueOrErr = MPReader.read(Obj);
693 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
694 EXPECT_TRUE(*ContinueOrErr);
695 EXPECT_EQ(Obj.Kind, Type::Map);
696 EXPECT_EQ(Obj.Length, 1u);
697}
698
699TEST_F(MsgPackReader, TestReadFixMapMax) {
700 Buffer = "\x8f";
701 Reader MPReader(Buffer);
702 auto ContinueOrErr = MPReader.read(Obj);
703 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
704 EXPECT_TRUE(*ContinueOrErr);
705 EXPECT_EQ(Obj.Kind, Type::Map);
706 // FixMap format's size is a 4 bit unsigned integer, so max is 1111 = 15
707 EXPECT_EQ(Obj.Length, 15u);
708}
709
710TEST_F(MsgPackReader, TestReadMap16Zero) {
711 Buffer.assign(s: "\xde\x00\x00", n: 3);
712 Reader MPReader(Buffer);
713 auto ContinueOrErr = MPReader.read(Obj);
714 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
715 EXPECT_TRUE(*ContinueOrErr);
716 EXPECT_EQ(Obj.Kind, Type::Map);
717 EXPECT_EQ(Obj.Length, 0u);
718}
719
720TEST_F(MsgPackReader, TestReadMap16One) {
721 Buffer.assign(s: "\xde\x00\x01", n: 3);
722 Reader MPReader(Buffer);
723 auto ContinueOrErr = MPReader.read(Obj);
724 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
725 EXPECT_TRUE(*ContinueOrErr);
726 EXPECT_EQ(Obj.Kind, Type::Map);
727 EXPECT_EQ(Obj.Length, 1u);
728}
729
730TEST_F(MsgPackReader, TestReadMap16Max) {
731 Buffer = "\xde\xff\xff";
732 Reader MPReader(Buffer);
733 auto ContinueOrErr = MPReader.read(Obj);
734 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
735 EXPECT_TRUE(*ContinueOrErr);
736 EXPECT_EQ(Obj.Kind, Type::Map);
737 EXPECT_EQ(Obj.Length, static_cast<uint16_t>(UINT16_MAX));
738}
739
740TEST_F(MsgPackReader, TestReadMap32Zero) {
741 Buffer.assign(s: "\xdf\x00\x00\x00\x00", n: 5);
742 Reader MPReader(Buffer);
743 auto ContinueOrErr = MPReader.read(Obj);
744 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
745 EXPECT_TRUE(*ContinueOrErr);
746 EXPECT_EQ(Obj.Kind, Type::Map);
747 EXPECT_EQ(Obj.Length, 0u);
748}
749
750TEST_F(MsgPackReader, TestReadMap32One) {
751 Buffer.assign(s: "\xdf\x00\x00\x00\x01", n: 5);
752 Reader MPReader(Buffer);
753 auto ContinueOrErr = MPReader.read(Obj);
754 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
755 EXPECT_TRUE(*ContinueOrErr);
756 EXPECT_EQ(Obj.Kind, Type::Map);
757 EXPECT_EQ(Obj.Length, 1u);
758}
759
760TEST_F(MsgPackReader, TestReadMap32Max) {
761 Buffer = "\xdf\xff\xff\xff\xff";
762 Reader MPReader(Buffer);
763 auto ContinueOrErr = MPReader.read(Obj);
764 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
765 EXPECT_TRUE(*ContinueOrErr);
766 EXPECT_EQ(Obj.Kind, Type::Map);
767 EXPECT_EQ(Obj.Length, static_cast<uint32_t>(UINT32_MAX));
768}
769
770// FixExt formats are only available for these specific lengths: 1, 2, 4, 8, 16
771
772TEST_F(MsgPackReader, TestReadFixExt1) {
773 std::string Result(1, 'a');
774 Buffer = std::string("\xd4\x01") + Result;
775 Reader MPReader(Buffer);
776 auto ContinueOrErr = MPReader.read(Obj);
777 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
778 EXPECT_TRUE(*ContinueOrErr);
779 EXPECT_EQ(Obj.Kind, Type::Extension);
780 EXPECT_EQ(Obj.Extension.Type, 0x01);
781 EXPECT_EQ(Obj.Extension.Bytes, Result);
782}
783
784TEST_F(MsgPackReader, TestReadFixExt2) {
785 std::string Result(2, 'a');
786 Buffer = std::string("\xd5\x01") + Result;
787 Reader MPReader(Buffer);
788 auto ContinueOrErr = MPReader.read(Obj);
789 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
790 EXPECT_TRUE(*ContinueOrErr);
791 EXPECT_EQ(Obj.Kind, Type::Extension);
792 EXPECT_EQ(Obj.Extension.Type, 0x01);
793 EXPECT_EQ(Obj.Extension.Bytes, Result);
794}
795
796TEST_F(MsgPackReader, TestReadFixExt4) {
797 std::string Result(4, 'a');
798 Buffer = std::string("\xd6\x01") + Result;
799 Reader MPReader(Buffer);
800 auto ContinueOrErr = MPReader.read(Obj);
801 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
802 EXPECT_TRUE(*ContinueOrErr);
803 EXPECT_EQ(Obj.Kind, Type::Extension);
804 EXPECT_EQ(Obj.Extension.Type, 0x01);
805 EXPECT_EQ(Obj.Extension.Bytes, Result);
806}
807
808TEST_F(MsgPackReader, TestReadFixExt8) {
809 std::string Result(8, 'a');
810 Buffer = std::string("\xd7\x01") + Result;
811 Reader MPReader(Buffer);
812 auto ContinueOrErr = MPReader.read(Obj);
813 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
814 EXPECT_TRUE(*ContinueOrErr);
815 EXPECT_EQ(Obj.Kind, Type::Extension);
816 EXPECT_EQ(Obj.Extension.Type, 0x01);
817 EXPECT_EQ(Obj.Extension.Bytes, Result);
818}
819
820TEST_F(MsgPackReader, TestReadFixExt16) {
821 std::string Result(16, 'a');
822 Buffer = std::string("\xd8\x01") + Result;
823 Reader MPReader(Buffer);
824 auto ContinueOrErr = MPReader.read(Obj);
825 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
826 EXPECT_TRUE(*ContinueOrErr);
827 EXPECT_EQ(Obj.Kind, Type::Extension);
828 EXPECT_EQ(Obj.Extension.Type, 0x01);
829 EXPECT_EQ(Obj.Extension.Bytes, Result);
830}
831
832TEST_F(MsgPackReader, TestReadExt8Min) {
833 // There are fix variants for sizes 1 and 2
834 Buffer.assign(s: "\xc7\x00\x01", n: 3);
835 Reader MPReader(Buffer);
836 auto ContinueOrErr = MPReader.read(Obj);
837 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
838 EXPECT_TRUE(*ContinueOrErr);
839 EXPECT_EQ(Obj.Kind, Type::Extension);
840 EXPECT_EQ(Obj.Extension.Type, 0x01);
841 EXPECT_EQ(Obj.Extension.Bytes, StringRef());
842}
843
844TEST_F(MsgPackReader, TestReadExt8Max) {
845 std::string Result(UINT8_MAX, 'a');
846 Buffer = std::string("\xc7\xff\x01", 3) + Result;
847 Reader MPReader(Buffer);
848 auto ContinueOrErr = MPReader.read(Obj);
849 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
850 EXPECT_TRUE(*ContinueOrErr);
851 EXPECT_EQ(Obj.Kind, Type::Extension);
852 EXPECT_EQ(Obj.Extension.Type, 0x01);
853 EXPECT_EQ(Obj.Extension.Bytes, Result);
854}
855
856TEST_F(MsgPackReader, TestReadExt16Min) {
857 std::string Result(static_cast<uint16_t>(UINT8_MAX) + 1, 'a');
858 Buffer = std::string("\xc8\x01\x00\x01", 4) + Result;
859 Reader MPReader(Buffer);
860 auto ContinueOrErr = MPReader.read(Obj);
861 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
862 EXPECT_TRUE(*ContinueOrErr);
863 EXPECT_EQ(Obj.Kind, Type::Extension);
864 EXPECT_EQ(Obj.Extension.Type, 0x01);
865 EXPECT_EQ(Obj.Extension.Bytes, Result);
866}
867
868TEST_F(MsgPackReader, TestReadExt16Max) {
869 std::string Result(UINT16_MAX, 'a');
870 Buffer = std::string("\xc8\xff\xff\x01") + Result;
871 Reader MPReader(Buffer);
872 auto ContinueOrErr = MPReader.read(Obj);
873 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
874 EXPECT_TRUE(*ContinueOrErr);
875 EXPECT_EQ(Obj.Kind, Type::Extension);
876 EXPECT_EQ(Obj.Extension.Type, 0x01);
877 EXPECT_EQ(Obj.Extension.Bytes, Result);
878}
879
880TEST_F(MsgPackReader, TestReadExt32Min) {
881 std::string Result(static_cast<uint32_t>(UINT16_MAX) + 1, 'a');
882 Buffer = std::string("\xc9\x00\x01\x00\x00\x01", 6) + Result;
883 Reader MPReader(Buffer);
884 auto ContinueOrErr = MPReader.read(Obj);
885 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
886 EXPECT_TRUE(*ContinueOrErr);
887 EXPECT_EQ(Obj.Kind, Type::Extension);
888 EXPECT_EQ(Obj.Extension.Type, 0x01);
889 EXPECT_EQ(Obj.Extension.Bytes, Result);
890}
891

source code of llvm/unittests/BinaryFormat/MsgPackReaderTest.cpp