Debian Codegraph @

llvm-project/llvm/unittests/Support/ScopedPrinterTest.cpp

raw
1 //===- llvm/unittest/Support/ScopedPrinterTest.cpp - ScopedPrinter tests --===//
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/Support/ScopedPrinter.h"
10 #include "llvm/ADT/APSInt.h"
11 #include "gtest/gtest.h"
12 #include <vector>
13
14 using namespace llvm;
15
16 TEST(JSONScopedPrinterTest, PrettyPrintCtor) {
17 auto PrintFunc = [](ScopedPrinter &W) {
18 DictScope D(W);
19 W.printString("Key", "Value");
20 };
21 std::string StreamBuffer;
22 raw_string_ostream OS(StreamBuffer);
23 JSONScopedPrinter PrettyPrintWriter(OS, /*PrettyPrint=*/true);
24 JSONScopedPrinter NoPrettyPrintWriter(OS, /*PrettyPrint=*/false);
25
26 const char *PrettyPrintOut = R"({
27 "Key": "Value"
28 })";
29 const char *NoPrettyPrintOut = R"({"Key":"Value"})";
30 PrintFunc(PrettyPrintWriter);
31 EXPECT_EQ(PrettyPrintOut, OS.str());
32 StreamBuffer.clear();
33 PrintFunc(NoPrettyPrintWriter);
34 EXPECT_EQ(NoPrettyPrintOut, OS.str());
35 }
36
37 TEST(JSONScopedPrinterTest, DelimitedScopeCtor) {
38 std::string StreamBuffer;
39 raw_string_ostream OS(StreamBuffer);
40 {
41 JSONScopedPrinter DictScopeWriter(OS, /*PrettyPrint=*/false,
42 std::make_unique<DictScope>());
43 DictScopeWriter.printString("Label", "DictScope");
44 }
45 EXPECT_EQ(R"({"Label":"DictScope"})", OS.str());
46 StreamBuffer.clear();
47 {
48 JSONScopedPrinter ListScopeWriter(OS, /*PrettyPrint=*/false,
49 std::make_unique<ListScope>());
50 ListScopeWriter.printString("ListScope");
51 }
52 EXPECT_EQ(R"(["ListScope"])", OS.str());
53 StreamBuffer.clear();
54 {
55 JSONScopedPrinter NoScopeWriter(OS, /*PrettyPrint=*/false);
56 NoScopeWriter.printString("NoScope");
57 }
58 EXPECT_EQ(R"("NoScope")", OS.str());
59 }
60
61 class ScopedPrinterTest : public ::testing::Test {
62 protected:
63 std::string StreamBuffer;
64 raw_string_ostream OS;
65 ScopedPrinter Writer;
66 JSONScopedPrinter JSONWriter;
67
68 bool HasPrintedToJSON;
69
70 ScopedPrinterTest()
71 : OS(StreamBuffer), Writer(OS), JSONWriter(OS, /*PrettyPrint=*/true),
72 HasPrintedToJSON(false) {}
73
74 using PrintFunc = function_ref<void(ScopedPrinter &)>;
75
76 void verifyScopedPrinter(StringRef Expected, PrintFunc Func) {
77 Func(Writer);
78 Writer.flush();
79 EXPECT_EQ(Expected.str(), OS.str());
80 StreamBuffer.clear();
81 }
82
83 void verifyJSONScopedPrinter(StringRef Expected, PrintFunc Func) {
84 {
85 DictScope D(JSONWriter);
86 Func(JSONWriter);
87 }
88 JSONWriter.flush();
89 EXPECT_EQ(Expected.str(), OS.str());
90 StreamBuffer.clear();
91 HasPrintedToJSON = true;
92 }
93
94 void verifyAll(StringRef ExpectedOut, StringRef JSONExpectedOut,
95 PrintFunc Func) {
96 verifyScopedPrinter(ExpectedOut, Func);
97 verifyJSONScopedPrinter(JSONExpectedOut, Func);
98 }
99
100 void TearDown() {
101 // JSONScopedPrinter fails an assert if nothing's been printed.
102 if (!HasPrintedToJSON)
103 JSONWriter.printString("");
104 }
105 };
106
107 TEST_F(ScopedPrinterTest, GetKind) {
108 EXPECT_EQ(ScopedPrinter::ScopedPrinterKind::Base, Writer.getKind());
109 EXPECT_EQ(ScopedPrinter::ScopedPrinterKind::JSON, JSONWriter.getKind());
110 }
111
112 TEST_F(ScopedPrinterTest, ClassOf) {
113 EXPECT_TRUE(ScopedPrinter::classof(&Writer));
114 EXPECT_TRUE(JSONScopedPrinter::classof(&JSONWriter));
115 EXPECT_FALSE(ScopedPrinter::classof(&JSONWriter));
116 EXPECT_FALSE(JSONScopedPrinter::classof(&Writer));
117 }
118
119 TEST_F(ScopedPrinterTest, Indent) {
120 auto PrintFunc = [](ScopedPrinter &W) {
121 W.printString("|");
122 W.indent();
123 W.printString("|");
124 W.indent(2);
125 W.printString("|");
126 };
127
128 const char *ExpectedOut = R"(|
129 |
130 |
131 )";
132 verifyScopedPrinter(ExpectedOut, PrintFunc);
133 }
134
135 TEST_F(ScopedPrinterTest, Unindent) {
136 auto PrintFunc = [](ScopedPrinter &W) {
137 W.indent(3);
138 W.printString("|");
139 W.unindent(2);
140 W.printString("|");
141 W.unindent();
142 W.printString("|");
143 W.unindent();
144 W.printString("|");
145 };
146
147 const char *ExpectedOut = R"( |
148 |
149 |
150 |
151 )";
152 verifyScopedPrinter(ExpectedOut, PrintFunc);
153 }
154
155 TEST_F(ScopedPrinterTest, ResetIndent) {
156 auto PrintFunc = [](ScopedPrinter &W) {
157 W.indent(4);
158 W.printString("|");
159 W.resetIndent();
160 W.printString("|");
161 };
162
163 const char *ExpectedOut = R"( |
164 |
165 )";
166 verifyScopedPrinter(ExpectedOut, PrintFunc);
167 }
168
169 TEST_F(ScopedPrinterTest, PrintIndent) {
170 auto PrintFunc = [](ScopedPrinter &W) {
171 W.printIndent();
172 W.printString("|");
173 W.indent();
174 W.printIndent();
175 W.printString("|");
176 };
177
178 const char *ExpectedOut = R"(|
179 |
180 )";
181 verifyScopedPrinter(ExpectedOut, PrintFunc);
182 }
183
184 TEST_F(ScopedPrinterTest, GetIndentLevel) {
185 EXPECT_EQ(Writer.getIndentLevel(), 0);
186 Writer.indent();
187 EXPECT_EQ(Writer.getIndentLevel(), 1);
188 Writer.indent();
189 EXPECT_EQ(Writer.getIndentLevel(), 2);
190 Writer.unindent();
191 EXPECT_EQ(Writer.getIndentLevel(), 1);
192 Writer.indent();
193 Writer.resetIndent();
194 EXPECT_EQ(Writer.getIndentLevel(), 0);
195 Writer.unindent();
196 EXPECT_EQ(Writer.getIndentLevel(), 0);
197 Writer.indent();
198 EXPECT_EQ(Writer.getIndentLevel(), 1);
199 }
200
201 TEST_F(ScopedPrinterTest, SetPrefix) {
202 auto PrintFunc = [](ScopedPrinter &W) {
203 W.setPrefix("Prefix1");
204 W.indent();
205 W.printIndent();
206 W.printString("|");
207 W.unindent();
208 W.printIndent();
209 W.printString("|");
210 W.setPrefix("Prefix2");
211 W.printIndent();
212 W.printString("|");
213 };
214
215 const char *ExpectedOut = R"(Prefix1 Prefix1 |
216 Prefix1Prefix1|
217 Prefix2Prefix2|
218 )";
219 verifyScopedPrinter(ExpectedOut, PrintFunc);
220 }
221
222 TEST_F(ScopedPrinterTest, PrintEnum) {
223 auto PrintFunc = [](ScopedPrinter &W) {
224 const EnumEntry<int> EnumList[] = {{"Name1", "AltName1", 1},
225 {"Name2", "AltName2", 2},
226 {"Name3", "AltName3", 3},
227 {"Name4", "AltName4", 2}};
228 EnumEntry<int> OtherEnum{"Name5", "AltName5", 5};
229 W.printEnum("Exists", EnumList[1].Value, ArrayRef(EnumList));
230 W.printEnum("DoesNotExist", OtherEnum.Value, ArrayRef(EnumList));
231 };
232
233 const char *ExpectedOut = R"(Exists: Name2 (0x2)
234 DoesNotExist: 0x5
235 )";
236
237 const char *JSONExpectedOut = R"({
238 "Exists": {
239 "Value": "Name2",
240 "RawValue": 2
241 },
242 "DoesNotExist": 5
243 })";
244 verifyAll(ExpectedOut, JSONExpectedOut, PrintFunc);
245 }
246
247 TEST_F(ScopedPrinterTest, PrintFlag) {
248 auto PrintFunc = [](ScopedPrinter &W) {
249 const EnumEntry<uint16_t> SingleBitFlags[] = {
250 {"Name0", "AltName0", 0},
251 {"Name1", "AltName1", 1},
252 {"Name2", "AltName2", 1 << 1},
253 {"Name3", "AltName3", 1 << 2}};
254 const EnumEntry<uint16_t> UnsortedFlags[] = {
255 {"C", "c", 1}, {"B", "b", 1 << 1}, {"A", "a", 1 << 2}};
256 const EnumEntry<uint16_t> EnumFlags[] = {
257 {"FirstByte1", "First1", 0x1u}, {"FirstByte2", "First2", 0x2u},
258 {"FirstByte3", "First3", 0x3u}, {"SecondByte1", "Second1", 0x10u},
259 {"SecondByte2", "Second2", 0x20u}, {"SecondByte3", "Second3", 0x30u},
260 {"ThirdByte1", "Third1", 0x100u}, {"ThirdByte2", "Third2", 0x200u},
261 {"ThirdByte3", "Third3", 0x300u}};
262 W.printFlags("ZeroFlag", 0, ArrayRef(SingleBitFlags));
263 W.printFlags("NoFlag", 1 << 3, ArrayRef(SingleBitFlags));
264 W.printFlags("Flag1", SingleBitFlags[1].Value, ArrayRef(SingleBitFlags));
265 W.printFlags("Flag1&3", (1 << 2) + 1, ArrayRef(SingleBitFlags));
266
267 W.printFlags("ZeroFlagRaw", 0);
268 W.printFlags("NoFlagRaw", 1 << 3);
269 W.printFlags("Flag1Raw", SingleBitFlags[1].Value);
270 W.printFlags("Flag1&3Raw", (1 << 2) + 1);
271
272 W.printFlags("FlagSorted", (1 << 2) + (1 << 1) + 1,
273 ArrayRef(UnsortedFlags));
274
275 uint16_t NoBitMask = 0;
276 uint16_t FirstByteMask = 0xFu;
277 uint16_t SecondByteMask = 0xF0u;
278 uint16_t ThirdByteMask = 0xF00u;
279 W.printFlags("NoBitMask", 0xFFFu, ArrayRef(EnumFlags), NoBitMask);
280 W.printFlags("FirstByteMask", 0x3u, ArrayRef(EnumFlags), FirstByteMask);
281 W.printFlags("SecondByteMask", 0x30u, ArrayRef(EnumFlags), SecondByteMask);
282 W.printFlags("ValueOutsideMask", 0x1u, ArrayRef(EnumFlags), SecondByteMask);
283 W.printFlags("FirstSecondByteMask", 0xFFu, ArrayRef(EnumFlags),
284 FirstByteMask, SecondByteMask);
285 W.printFlags("FirstSecondThirdByteMask", 0x333u, ArrayRef(EnumFlags),
286 FirstByteMask, SecondByteMask, ThirdByteMask);
287 };
288
289 const char *ExpectedOut = R"(ZeroFlag [ (0x0)
290 ]
291 NoFlag [ (0x8)
292 ]
293 Flag1 [ (0x1)
294 Name1 (0x1)
295 ]
296 Flag1&3 [ (0x5)
297 Name1 (0x1)
298 Name3 (0x4)
299 ]
300 ZeroFlagRaw [ (0x0)
301 ]
302 NoFlagRaw [ (0x8)
303 0x8
304 ]
305 Flag1Raw [ (0x1)
306 0x1
307 ]
308 Flag1&3Raw [ (0x5)
309 0x1
310 0x4
311 ]
312 FlagSorted [ (0x7)
313 A (0x4)
314 B (0x2)
315 C (0x1)
316 ]
317 NoBitMask [ (0xFFF)
318 FirstByte1 (0x1)
319 FirstByte2 (0x2)
320 FirstByte3 (0x3)
321 SecondByte1 (0x10)
322 SecondByte2 (0x20)
323 SecondByte3 (0x30)
324 ThirdByte1 (0x100)
325 ThirdByte2 (0x200)
326 ThirdByte3 (0x300)
327 ]
328 FirstByteMask [ (0x3)
329 FirstByte3 (0x3)
330 ]
331 SecondByteMask [ (0x30)
332 SecondByte3 (0x30)
333 ]
334 ValueOutsideMask [ (0x1)
335 FirstByte1 (0x1)
336 ]
337 FirstSecondByteMask [ (0xFF)
338 ]
339 FirstSecondThirdByteMask [ (0x333)
340 FirstByte3 (0x3)
341 SecondByte3 (0x30)
342 ThirdByte3 (0x300)
343 ]
344 )";
345
346 const char *JSONExpectedOut = R"({
347 "ZeroFlag": {
348 "RawFlags": 0,
349 "Flags": []
350 },
351 "NoFlag": {
352 "RawFlags": 8,
353 "Flags": []
354 },
355 "Flag1": {
356 "RawFlags": 1,
357 "Flags": [
358 {
359 "Name": "Name1",
360 "Value": 1
361 }
362 ]
363 },
364 "Flag1&3": {
365 "RawFlags": 5,
366 "Flags": [
367 {
368 "Name": "Name1",
369 "Value": 1
370 },
371 {
372 "Name": "Name3",
373 "Value": 4
374 }
375 ]
376 },
377 "ZeroFlagRaw": {
378 "RawFlags": 0,
379 "Flags": []
380 },
381 "NoFlagRaw": {
382 "RawFlags": 8,
383 "Flags": [
384 8
385 ]
386 },
387 "Flag1Raw": {
388 "RawFlags": 1,
389 "Flags": [
390 1
391 ]
392 },
393 "Flag1&3Raw": {
394 "RawFlags": 5,
395 "Flags": [
396 1,
397 4
398 ]
399 },
400 "FlagSorted": {
401 "RawFlags": 7,
402 "Flags": [
403 {
404 "Name": "A",
405 "Value": 4
406 },
407 {
408 "Name": "B",
409 "Value": 2
410 },
411 {
412 "Name": "C",
413 "Value": 1
414 }
415 ]
416 },
417 "NoBitMask": {
418 "RawFlags": 4095,
419 "Flags": [
420 {
421 "Name": "FirstByte1",
422 "Value": 1
423 },
424 {
425 "Name": "FirstByte2",
426 "Value": 2
427 },
428 {
429 "Name": "FirstByte3",
430 "Value": 3
431 },
432 {
433 "Name": "SecondByte1",
434 "Value": 16
435 },
436 {
437 "Name": "SecondByte2",
438 "Value": 32
439 },
440 {
441 "Name": "SecondByte3",
442 "Value": 48
443 },
444 {
445 "Name": "ThirdByte1",
446 "Value": 256
447 },
448 {
449 "Name": "ThirdByte2",
450 "Value": 512
451 },
452 {
453 "Name": "ThirdByte3",
454 "Value": 768
455 }
456 ]
457 },
458 "FirstByteMask": {
459 "RawFlags": 3,
460 "Flags": [
461 {
462 "Name": "FirstByte3",
463 "Value": 3
464 }
465 ]
466 },
467 "SecondByteMask": {
468 "RawFlags": 48,
469 "Flags": [
470 {
471 "Name": "SecondByte3",
472 "Value": 48
473 }
474 ]
475 },
476 "ValueOutsideMask": {
477 "RawFlags": 1,
478 "Flags": [
479 {
480 "Name": "FirstByte1",
481 "Value": 1
482 }
483 ]
484 },
485 "FirstSecondByteMask": {
486 "RawFlags": 255,
487 "Flags": []
488 },
489 "FirstSecondThirdByteMask": {
490 "RawFlags": 819,
491 "Flags": [
492 {
493 "Name": "FirstByte3",
494 "Value": 3
495 },
496 {
497 "Name": "SecondByte3",
498 "Value": 48
499 },
500 {
501 "Name": "ThirdByte3",
502 "Value": 768
503 }
504 ]
505 }
506 })";
507 verifyAll(ExpectedOut, JSONExpectedOut, PrintFunc);
508 }
509
510 TEST_F(ScopedPrinterTest, PrintNumber) {
511 auto PrintFunc = [](ScopedPrinter &W) {
512 uint64_t Unsigned64Max = std::numeric_limits<uint64_t>::max();
513 uint64_t Unsigned64Min = std::numeric_limits<uint64_t>::min();
514 W.printNumber("uint64_t-max", Unsigned64Max);
515 W.printNumber("uint64_t-min", Unsigned64Min);
516
517 uint32_t Unsigned32Max = std::numeric_limits<uint32_t>::max();
518 uint32_t Unsigned32Min = std::numeric_limits<uint32_t>::min();
519 W.printNumber("uint32_t-max", Unsigned32Max);
520 W.printNumber("uint32_t-min", Unsigned32Min);
521
522 uint16_t Unsigned16Max = std::numeric_limits<uint16_t>::max();
523 uint16_t Unsigned16Min = std::numeric_limits<uint16_t>::min();
524 W.printNumber("uint16_t-max", Unsigned16Max);
525 W.printNumber("uint16_t-min", Unsigned16Min);
526
527 uint8_t Unsigned8Max = std::numeric_limits<uint8_t>::max();
528 uint8_t Unsigned8Min = std::numeric_limits<uint8_t>::min();
529 W.printNumber("uint8_t-max", Unsigned8Max);
530 W.printNumber("uint8_t-min", Unsigned8Min);
531
532 int64_t Signed64Max = std::numeric_limits<int64_t>::max();
533 int64_t Signed64Min = std::numeric_limits<int64_t>::min();
534 W.printNumber("int64_t-max", Signed64Max);
535 W.printNumber("int64_t-min", Signed64Min);
536
537 int32_t Signed32Max = std::numeric_limits<int32_t>::max();
538 int32_t Signed32Min = std::numeric_limits<int32_t>::min();
539 W.printNumber("int32_t-max", Signed32Max);
540 W.printNumber("int32_t-min", Signed32Min);
541
542 int16_t Signed16Max = std::numeric_limits<int16_t>::max();
543 int16_t Signed16Min = std::numeric_limits<int16_t>::min();
544 W.printNumber("int16_t-max", Signed16Max);
545 W.printNumber("int16_t-min", Signed16Min);
546
547 int8_t Signed8Max = std::numeric_limits<int8_t>::max();
548 int8_t Signed8Min = std::numeric_limits<int8_t>::min();
549 W.printNumber("int8_t-max", Signed8Max);
550 W.printNumber("int8_t-min", Signed8Min);
551
552 APSInt LargeNum("9999999999999999999999");
553 W.printNumber("apsint", LargeNum);
554
555 W.printNumber("label", "value", 0);
556 };
557
558 const char *ExpectedOut = R"(uint64_t-max: 18446744073709551615
559 uint64_t-min: 0
560 uint32_t-max: 4294967295
561 uint32_t-min: 0
562 uint16_t-max: 65535
563 uint16_t-min: 0
564 uint8_t-max: 255
565 uint8_t-min: 0
566 int64_t-max: 9223372036854775807
567 int64_t-min: -9223372036854775808
568 int32_t-max: 2147483647
569 int32_t-min: -2147483648
570 int16_t-max: 32767
571 int16_t-min: -32768
572 int8_t-max: 127
573 int8_t-min: -128
574 apsint: 9999999999999999999999
575 label: value (0)
576 )";
577
578 const char *JSONExpectedOut = R"({
579 "uint64_t-max": 18446744073709551615,
580 "uint64_t-min": 0,
581 "uint32_t-max": 4294967295,
582 "uint32_t-min": 0,
583 "uint16_t-max": 65535,
584 "uint16_t-min": 0,
585 "uint8_t-max": 255,
586 "uint8_t-min": 0,
587 "int64_t-max": 9223372036854775807,
588 "int64_t-min": -9223372036854775808,
589 "int32_t-max": 2147483647,
590 "int32_t-min": -2147483648,
591 "int16_t-max": 32767,
592 "int16_t-min": -32768,
593 "int8_t-max": 127,
594 "int8_t-min": -128,
595 "apsint": 9999999999999999999999,
596 "label": {
597 "Value": "value",
598 "RawValue": 0
599 }
600 })";
601 verifyAll(ExpectedOut, JSONExpectedOut, PrintFunc);
602 }
603
604 TEST_F(ScopedPrinterTest, PrintBoolean) {
605 auto PrintFunc = [](ScopedPrinter &W) {
606 W.printBoolean("True", true);
607 W.printBoolean("False", false);
608 };
609
610 const char *ExpectedOut = R"(True: Yes
611 False: No
612 )";
613
614 const char *JSONExpectedOut = R"({
615 "True": true,
616 "False": false
617 })";
618 verifyAll(ExpectedOut, JSONExpectedOut, PrintFunc);
619 }
620
621 TEST_F(ScopedPrinterTest, PrintVersion) {
622 auto PrintFunc = [](ScopedPrinter &W) {
623 W.printVersion("Version", "123", "456", "789");
624 };
625 const char *ExpectedOut = R"(Version: 123.456.789
626 )";
627 verifyScopedPrinter(ExpectedOut, PrintFunc);
628 }
629
630 TEST_F(ScopedPrinterTest, PrintList) {
631 auto PrintFunc = [](ScopedPrinter &W) {
632 const std::vector<uint64_t> EmptyList;
633 const std::vector<std::string> StringList = {"foo", "bar", "baz"};
634 const bool BoolList[] = {true, false};
635 const std::vector<uint64_t> Unsigned64List = {
636 std::numeric_limits<uint64_t>::max(),
637 std::numeric_limits<uint64_t>::min()};
638 const std::vector<uint32_t> Unsigned32List = {
639 std::numeric_limits<uint32_t>::max(),
640 std::numeric_limits<uint32_t>::min()};
641 const std::vector<uint16_t> Unsigned16List = {
642 std::numeric_limits<uint16_t>::max(),
643 std::numeric_limits<uint16_t>::min()};
644 const std::vector<uint8_t> Unsigned8List = {
645 std::numeric_limits<uint8_t>::max(),
646 std::numeric_limits<uint8_t>::min()};
647 const std::vector<int64_t> Signed64List = {
648 std::numeric_limits<int64_t>::max(),
649 std::numeric_limits<int64_t>::min()};
650 const std::vector<int32_t> Signed32List = {
651 std::numeric_limits<int32_t>::max(),
652 std::numeric_limits<int32_t>::min()};
653 const std::vector<int16_t> Signed16List = {
654 std::numeric_limits<int16_t>::max(),
655 std::numeric_limits<int16_t>::min()};
656 const std::vector<int8_t> Signed8List = {
657 std::numeric_limits<int8_t>::max(), std::numeric_limits<int8_t>::min()};
658 const std::vector<APSInt> APSIntList = {APSInt("9999999999999999999999"),
659 APSInt("-9999999999999999999999")};
660 W.printList("EmptyList", EmptyList);
661 W.printList("StringList", StringList);
662 W.printList("BoolList", ArrayRef(BoolList));
663 W.printList("uint64List", Unsigned64List);
664 W.printList("uint32List", Unsigned32List);
665 W.printList("uint16List", Unsigned16List);
666 W.printList("uint8List", Unsigned8List);
667 W.printList("int64List", Signed64List);
668 W.printList("int32List", Signed32List);
669 W.printList("int16List", Signed16List);
670 W.printList("int8List", Signed8List);
671 W.printList("APSIntList", APSIntList);
672 };
673
674 const char *ExpectedOut = R"(EmptyList: []
675 StringList: [foo, bar, baz]
676 BoolList: [1, 0]
677 uint64List: [18446744073709551615, 0]
678 uint32List: [4294967295, 0]
679 uint16List: [65535, 0]
680 uint8List: [255, 0]
681 int64List: [9223372036854775807, -9223372036854775808]
682 int32List: [2147483647, -2147483648]
683 int16List: [32767, -32768]
684 int8List: [127, -128]
685 APSIntList: [9999999999999999999999, -9999999999999999999999]
686 )";
687
688 const char *JSONExpectedOut = R"({
689 "EmptyList": [],
690 "StringList": [
691 "foo",
692 "bar",
693 "baz"
694 ],
695 "BoolList": [
696 true,
697 false
698 ],
699 "uint64List": [
700 18446744073709551615,
701 0
702 ],
703 "uint32List": [
704 4294967295,
705 0
706 ],
707 "uint16List": [
708 65535,
709 0
710 ],
711 "uint8List": [
712 255,
713 0
714 ],
715 "int64List": [
716 9223372036854775807,
717 -9223372036854775808
718 ],
719 "int32List": [
720 2147483647,
721 -2147483648
722 ],
723 "int16List": [
724 32767,
725 -32768
726 ],
727 "int8List": [
728 127,
729 -128
730 ],
731 "APSIntList": [
732 9999999999999999999999,
733 -9999999999999999999999
734 ]
735 })";
736 verifyAll(ExpectedOut, JSONExpectedOut, PrintFunc);
737 }
738
739 TEST_F(ScopedPrinterTest, PrintListPrinter) {
740 auto PrintFunc = [](ScopedPrinter &W) {
741 const std::string StringList[] = {"a", "ab", "abc"};
742 W.printList("StringSizeList", StringList,
743 [](raw_ostream &OS, StringRef Item) { OS << Item.size(); });
744 };
745
746 const char *ExpectedOut = R"(StringSizeList: [1, 2, 3]
747 )";
748 verifyScopedPrinter(ExpectedOut, PrintFunc);
749 }
750
751 TEST_F(ScopedPrinterTest, PrintHex) {
752 auto PrintFunc = [](ScopedPrinter &W) {
753 W.printHex("HexNumber", 0x10);
754 W.printHex("HexLabel", "Name", 0x10);
755 };
756
757 const char *ExpectedOut = R"(HexNumber: 0x10
758 HexLabel: Name (0x10)
759 )";
760
761 const char *JSONExpectedOut = R"({
762 "HexNumber": 16,
763 "HexLabel": {
764 "Value": "Name",
765 "RawValue": 16
766 }
767 })";
768 verifyAll(ExpectedOut, JSONExpectedOut, PrintFunc);
769 }
770
771 TEST_F(ScopedPrinterTest, PrintHexList) {
772 auto PrintFunc = [](ScopedPrinter &W) {
773 const uint64_t HexList[] = {0x1, 0x10, 0x100};
774 W.printHexList("HexList", HexList);
775 };
776 const char *ExpectedOut = R"(HexList: [0x1, 0x10, 0x100]
777 )";
778
779 const char *JSONExpectedOut = R"({
780 "HexList": [
781 1,
782 16,
783 256
784 ]
785 })";
786 verifyAll(ExpectedOut, JSONExpectedOut, PrintFunc);
787 }
788
789 TEST_F(ScopedPrinterTest, PrintSymbolOffset) {
790 auto PrintFunc = [](ScopedPrinter &W) {
791 W.printSymbolOffset("SymbolOffset", "SymbolName", 0x10);
792 W.printSymbolOffset("NoSymbolOffset", "SymbolName", 0);
793 };
794 const char *ExpectedOut = R"(SymbolOffset: SymbolName+0x10
795 NoSymbolOffset: SymbolName+0x0
796 )";
797
798 const char *JSONExpectedOut = R"({
799 "SymbolOffset": {
800 "SymName": "SymbolName",
801 "Offset": 16
802 },
803 "NoSymbolOffset": {
804 "SymName": "SymbolName",
805 "Offset": 0
806 }
807 })";
808 verifyAll(ExpectedOut, JSONExpectedOut, PrintFunc);
809 }
810
811 TEST_F(ScopedPrinterTest, PrintString) {
812 auto PrintFunc = [](ScopedPrinter &W) {
813 const StringRef StringRefValue("Value");
814 const std::string StringValue = "Value";
815 const char *CharArrayValue = "Value";
816 W.printString("StringRef", StringRefValue);
817 W.printString("String", StringValue);
818 W.printString("CharArray", CharArrayValue);
819 ListScope L(W, "StringList");
820 W.printString(StringRefValue);
821 };
822
823 const char *ExpectedOut = R"(StringRef: Value
824 String: Value
825 CharArray: Value
826 StringList [
827 Value
828 ]
829 )";
830
831 const char *JSONExpectedOut = R"({
832 "StringRef": "Value",
833 "String": "Value",
834 "CharArray": "Value",
835 "StringList": [
836 "Value"
837 ]
838 })";
839 verifyAll(ExpectedOut, JSONExpectedOut, PrintFunc);
840 }
841
842 TEST_F(ScopedPrinterTest, PrintBinary) {
843 auto PrintFunc = [](ScopedPrinter &W) {
844 std::vector<uint8_t> IntArray = {70, 111, 111, 66, 97, 114};
845 std::vector<char> CharArray = {'F', 'o', 'o', 'B', 'a', 'r'};
846 std::vector<uint8_t> InvalidChars = {255, 255};
847 W.printBinary("Binary1", "FooBar", IntArray);
848 W.printBinary("Binary2", "FooBar", CharArray);
849 W.printBinary("Binary3", IntArray);
850 W.printBinary("Binary4", CharArray);
851 W.printBinary("Binary5", StringRef("FooBar"));
852 W.printBinary("Binary6", StringRef("Multiple Line FooBar"));
853 W.printBinaryBlock("Binary7", IntArray, 20);
854 W.printBinaryBlock("Binary8", IntArray);
855 W.printBinaryBlock("Binary9", "FooBar");
856 W.printBinaryBlock("Binary10", "Multiple Line FooBar");
857 W.printBinaryBlock("Binary11", InvalidChars);
858 };
859
860 const char *ExpectedOut = R"(Binary1: FooBar (46 6F 6F 42 61 72)
861 Binary2: FooBar (46 6F 6F 42 61 72)
862 Binary3: (46 6F 6F 42 61 72)
863 Binary4: (46 6F 6F 42 61 72)
864 Binary5: (46 6F 6F 42 61 72)
865 Binary6 (
866 0000: 4D756C74 69706C65 204C696E 6520466F |Multiple Line Fo|
867 0010: 6F426172 |oBar|
868 )
869 Binary7 (
870 0014: 466F6F42 6172 |FooBar|
871 )
872 Binary8 (
873 0000: 466F6F42 6172 |FooBar|
874 )
875 Binary9 (
876 0000: 466F6F42 6172 |FooBar|
877 )
878 Binary10 (
879 0000: 4D756C74 69706C65 204C696E 6520466F |Multiple Line Fo|
880 0010: 6F426172 |oBar|
881 )
882 Binary11 (
883 0000: FFFF |..|
884 )
885 )";
886
887 const char *JSONExpectedOut = R"({
888 "Binary1": {
889 "Value": "FooBar",
890 "Offset": 0,
891 "Bytes": [
892 70,
893 111,
894 111,
895 66,
896 97,
897 114
898 ]
899 },
900 "Binary2": {
901 "Value": "FooBar",
902 "Offset": 0,
903 "Bytes": [
904 70,
905 111,
906 111,
907 66,
908 97,
909 114
910 ]
911 },
912 "Binary3": {
913 "Offset": 0,
914 "Bytes": [
915 70,
916 111,
917 111,
918 66,
919 97,
920 114
921 ]
922 },
923 "Binary4": {
924 "Offset": 0,
925 "Bytes": [
926 70,
927 111,
928 111,
929 66,
930 97,
931 114
932 ]
933 },
934 "Binary5": {
935 "Offset": 0,
936 "Bytes": [
937 70,
938 111,
939 111,
940 66,
941 97,
942 114
943 ]
944 },
945 "Binary6": {
946 "Offset": 0,
947 "Bytes": [
948 77,
949 117,
950 108,
951 116,
952 105,
953 112,
954 108,
955 101,
956 32,
957 76,
958 105,
959 110,
960 101,
961 32,
962 70,
963 111,
964 111,
965 66,
966 97,
967 114
968 ]
969 },
970 "Binary7": {
971 "Offset": 20,
972 "Bytes": [
973 70,
974 111,
975 111,
976 66,
977 97,
978 114
979 ]
980 },
981 "Binary8": {
982 "Offset": 0,
983 "Bytes": [
984 70,
985 111,
986 111,
987 66,
988 97,
989 114
990 ]
991 },
992 "Binary9": {
993 "Offset": 0,
994 "Bytes": [
995 70,
996 111,
997 111,
998 66,
999 97,
1000 114
1001 ]
1002 },
1003 "Binary10": {
1004 "Offset": 0,
1005 "Bytes": [
1006 77,
1007 117,
1008 108,
1009 116,
1010 105,
1011 112,
1012 108,
1013 101,
1014 32,
1015 76,
1016 105,
1017 110,
1018 101,
1019 32,
1020 70,
1021 111,
1022 111,
1023 66,
1024 97,
1025 114
1026 ]
1027 },
1028 "Binary11": {
1029 "Offset": 0,
1030 "Bytes": [
1031 255,
1032 255
1033 ]
1034 }
1035 })";
1036 verifyAll(ExpectedOut, JSONExpectedOut, PrintFunc);
1037 }
1038
1039 TEST_F(ScopedPrinterTest, PrintObject) {
1040 auto PrintFunc = [](ScopedPrinter &W) { W.printObject("Object", "Value"); };
1041
1042 const char *ExpectedOut = R"(Object: Value
1043 )";
1044
1045 const char *JSONExpectedOut = R"({
1046 "Object": "Value"
1047 })";
1048 verifyAll(ExpectedOut, JSONExpectedOut, PrintFunc);
1049 }
1050
1051 TEST_F(ScopedPrinterTest, StartLine) {
1052 auto PrintFunc = [](ScopedPrinter &W) {
1053 W.startLine() << "|";
1054 W.indent(2);
1055 W.startLine() << "|";
1056 W.unindent();
1057 W.startLine() << "|";
1058 };
1059
1060 const char *ExpectedOut = "| | |";
1061 verifyScopedPrinter(ExpectedOut, PrintFunc);
1062 }
1063
1064 TEST_F(ScopedPrinterTest, GetOStream) {
1065 auto PrintFunc = [](ScopedPrinter &W) { W.getOStream() << "Test"; };
1066
1067 const char *ExpectedOut = "Test";
1068 verifyScopedPrinter(ExpectedOut, PrintFunc);
1069 }
1070
1071 TEST_F(ScopedPrinterTest, PrintScope) {
1072 auto PrintFunc = [](ScopedPrinter &W) {
1073 {
1074 DictScope O(W, "Object");
1075 { DictScope OO(W, "ObjectInObject"); }
1076 { ListScope LO(W, "ListInObject"); }
1077 }
1078 {
1079 ListScope L(W, "List");
1080 { DictScope OL(W, "ObjectInList"); }
1081 { ListScope LL(W, "ListInList"); }
1082 }
1083 };
1084
1085 const char *ExpectedOut = R"(Object {
1086 ObjectInObject {
1087 }
1088 ListInObject [
1089 ]
1090 }
1091 List [
1092 ObjectInList {
1093 }
1094 ListInList [
1095 ]
1096 ]
1097 )";
1098
1099 const char *JSONExpectedOut = R"({
1100 "Object": {
1101 "ObjectInObject": {},
1102 "ListInObject": []
1103 },
1104 "List": [
1105 {
1106 "ObjectInList": {}
1107 },
1108 {
1109 "ListInList": []
1110 }
1111 ]
1112 })";
1113 verifyAll(ExpectedOut, JSONExpectedOut, PrintFunc);
1114 }