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
13using namespace llvm;
14using namespace llvm::msgpack;
15
16struct 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
24TEST_F(MsgPackWriter, TestWriteNil) {
25 MPWriter.writeNil();
26 EXPECT_EQ(OStream.str(), "\xc0");
27}
28
29TEST_F(MsgPackWriter, TestWriteBool) {
30 MPWriter.write(b: true);
31 MPWriter.write(b: false);
32 EXPECT_EQ(OStream.str(), "\xc3\xc2");
33}
34
35TEST_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
47TEST_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
54TEST_F(MsgPackWriter, TestWriteUInt8) {
55 uint64_t u = 221;
56 MPWriter.write(u);
57 EXPECT_EQ(OStream.str(), "\xcc\xdd");
58}
59
60TEST_F(MsgPackWriter, TestWriteUInt8Max) {
61 uint64_t u = UINT8_MAX;
62 MPWriter.write(u);
63 EXPECT_EQ(OStream.str(), "\xcc\xff");
64}
65
66TEST_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
72TEST_F(MsgPackWriter, TestWriteUInt16) {
73 uint64_t u = 43981;
74 MPWriter.write(u);
75 EXPECT_EQ(OStream.str(), "\xcd\xab\xcd");
76}
77
78TEST_F(MsgPackWriter, TestWriteUInt16Max) {
79 uint64_t u = UINT16_MAX;
80 MPWriter.write(u);
81 EXPECT_EQ(OStream.str(), "\xcd\xff\xff");
82}
83
84TEST_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
90TEST_F(MsgPackWriter, TestWriteUInt32) {
91 uint64_t u = 2882400186;
92 MPWriter.write(u);
93 EXPECT_EQ(OStream.str(), "\xce\xab\xcd\xef\xba");
94}
95
96TEST_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
102TEST_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
109TEST_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
115TEST_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
121TEST_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
135TEST_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
142TEST_F(MsgPackWriter, TestWriteInt8) {
143 int64_t i = -40;
144 MPWriter.write(i);
145 EXPECT_EQ(OStream.str(), "\xd0\xd8");
146}
147
148TEST_F(MsgPackWriter, TestWriteInt8Min) {
149 int64_t i = INT8_MIN;
150 MPWriter.write(i);
151 EXPECT_EQ(OStream.str(), "\xd0\x80");
152}
153
154TEST_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
160TEST_F(MsgPackWriter, TestWriteInt16) {
161 int64_t i = -4369;
162 MPWriter.write(i);
163 EXPECT_EQ(OStream.str(), "\xd1\xee\xef");
164}
165
166TEST_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
172TEST_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
178TEST_F(MsgPackWriter, TestWriteInt32) {
179 int64_t i = -286331153;
180 MPWriter.write(i);
181 EXPECT_EQ(OStream.str(), "\xd2\xee\xee\xee\xef");
182}
183
184TEST_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
190TEST_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
196TEST_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
202TEST_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
209TEST_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
215TEST_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
221TEST_F(MsgPackWriter, TestWriteFixStrMin) {
222 std::string s;
223 MPWriter.write(s);
224 EXPECT_EQ(OStream.str(), "\xa0");
225}
226
227TEST_F(MsgPackWriter, TestWriteFixStr) {
228 std::string s = "foo";
229 MPWriter.write(s);
230 EXPECT_EQ(OStream.str(), "\xa3"
231 "foo");
232}
233
234TEST_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
241TEST_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
248TEST_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
254TEST_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
260TEST_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
266TEST_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
272TEST_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
278TEST_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
284TEST_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
290TEST_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
296TEST_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
302TEST_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
308TEST_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
314TEST_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
320TEST_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
326TEST_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
332TEST_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
338TEST_F(MsgPackWriter, TestWriteFixArrayMin) {
339 MPWriter.writeArraySize(Size: 0);
340 EXPECT_EQ(OStream.str(), "\x90");
341}
342
343TEST_F(MsgPackWriter, TestWriteFixArray) {
344 MPWriter.writeArraySize(Size: 4);
345 EXPECT_EQ(OStream.str(), "\x94");
346}
347
348TEST_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
354TEST_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
360TEST_F(MsgPackWriter, TestWriteArray16) {
361 MPWriter.writeArraySize(Size: 273);
362 EXPECT_EQ(OStream.str(), "\xdc\x01\x11");
363}
364
365TEST_F(MsgPackWriter, TestWriteArray16Max) {
366 MPWriter.writeArraySize(UINT16_MAX);
367 EXPECT_EQ(OStream.str(), "\xdc\xff\xff");
368}
369
370TEST_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
375TEST_F(MsgPackWriter, TestWriteArray32) {
376 MPWriter.writeArraySize(Size: 131071);
377 EXPECT_EQ(OStream.str(), std::string("\xdd\x00\x01\xff\xff", 5));
378}
379
380TEST_F(MsgPackWriter, TestWriteArray32Max) {
381 MPWriter.writeArraySize(UINT32_MAX);
382 EXPECT_EQ(OStream.str(), "\xdd\xff\xff\xff\xff");
383}
384
385TEST_F(MsgPackWriter, TestWriteFixMapMin) {
386 MPWriter.writeMapSize(Size: 0);
387 EXPECT_EQ(OStream.str(), "\x80");
388}
389
390TEST_F(MsgPackWriter, TestWriteFixMap) {
391 MPWriter.writeMapSize(Size: 4);
392 EXPECT_EQ(OStream.str(), "\x84");
393}
394
395TEST_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
401TEST_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
407TEST_F(MsgPackWriter, TestWriteMap16) {
408 MPWriter.writeMapSize(Size: 273);
409 EXPECT_EQ(OStream.str(), "\xde\x01\x11");
410}
411
412TEST_F(MsgPackWriter, TestWriteMap16Max) {
413 MPWriter.writeMapSize(UINT16_MAX);
414 EXPECT_EQ(OStream.str(), "\xde\xff\xff");
415}
416
417TEST_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
422TEST_F(MsgPackWriter, TestWriteMap32) {
423 MPWriter.writeMapSize(Size: 131071);
424 EXPECT_EQ(OStream.str(), std::string("\xdf\x00\x01\xff\xff", 5));
425}
426
427TEST_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
434TEST_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
440TEST_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
446TEST_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
452TEST_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
458TEST_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
464TEST_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
470TEST_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
476TEST_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
482TEST_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
488TEST_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
494TEST_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
500TEST_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
506TEST_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
513TEST_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

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