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(true);
31   MPWriter.write(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(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(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(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(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(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(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(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(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(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(0);
340   EXPECT_EQ(OStream.str(), "\x90");
341 }
342 
343 TEST_F(MsgPackWriter, TestWriteFixArray) {
344   MPWriter.writeArraySize(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(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(16);
357   EXPECT_EQ(OStream.str(), std::string("\xdc\x00\x10", 3));
358 }
359 
360 TEST_F(MsgPackWriter, TestWriteArray16) {
361   MPWriter.writeArraySize(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(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(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(0);
387   EXPECT_EQ(OStream.str(), "\x80");
388 }
389 
390 TEST_F(MsgPackWriter, TestWriteFixMap) {
391   MPWriter.writeMapSize(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(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(16);
404   EXPECT_EQ(OStream.str(), std::string("\xde\x00\x10", 3));
405 }
406 
407 TEST_F(MsgPackWriter, TestWriteMap16) {
408   MPWriter.writeMapSize(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(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(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(0x01, 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(0x01, 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(0x01, 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(0x01, 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(0x01, 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(0x01, 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(0x01, 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(0x01, 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(0x02, 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(0x01, 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(0x01, 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(0x02, 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