1 //===- unittest/Support/YAMLIOTest.cpp ------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "llvm/ADT/SmallString.h"
11 #include "llvm/ADT/Twine.h"
12 #include "llvm/Support/Casting.h"
13 #include "llvm/Support/Format.h"
14 #include "llvm/Support/YAMLTraits.h"
15 #include "gtest/gtest.h"
16
17
18 using llvm::yaml::Input;
19 using llvm::yaml::Output;
20 using llvm::yaml::IO;
21 using llvm::yaml::MappingTraits;
22 using llvm::yaml::MappingNormalization;
23 using llvm::yaml::ScalarTraits;
24 using llvm::yaml::Hex8;
25 using llvm::yaml::Hex16;
26 using llvm::yaml::Hex32;
27 using llvm::yaml::Hex64;
28
29
30 //===----------------------------------------------------------------------===//
31 // Test MappingTraits
32 //===----------------------------------------------------------------------===//
33
34 struct FooBar {
35 int foo;
36 int bar;
37 };
38 typedef std::vector<FooBar> FooBarSequence;
39
40 LLVM_YAML_IS_SEQUENCE_VECTOR(FooBar)
41
42
43 namespace llvm {
44 namespace yaml {
45 template <>
46 struct MappingTraits<FooBar> {
mappingllvm::yaml::MappingTraits47 static void mapping(IO &io, FooBar& fb) {
48 io.mapRequired("foo", fb.foo);
49 io.mapRequired("bar", fb.bar);
50 }
51 };
52 }
53 }
54
55
56 //
57 // Test the reading of a yaml mapping
58 //
TEST(YAMLIO,TestMapRead)59 TEST(YAMLIO, TestMapRead) {
60 FooBar doc;
61 Input yin("---\nfoo: 3\nbar: 5\n...\n");
62 yin >> doc;
63
64 EXPECT_FALSE(yin.error());
65 EXPECT_EQ(doc.foo, 3);
66 EXPECT_EQ(doc.bar,5);
67 }
68
69
70 //
71 // Test the reading of a yaml sequence of mappings
72 //
TEST(YAMLIO,TestSequenceMapRead)73 TEST(YAMLIO, TestSequenceMapRead) {
74 FooBarSequence seq;
75 Input yin("---\n - foo: 3\n bar: 5\n - foo: 7\n bar: 9\n...\n");
76 yin >> seq;
77
78 EXPECT_FALSE(yin.error());
79 EXPECT_EQ(seq.size(), 2UL);
80 FooBar& map1 = seq[0];
81 FooBar& map2 = seq[1];
82 EXPECT_EQ(map1.foo, 3);
83 EXPECT_EQ(map1.bar, 5);
84 EXPECT_EQ(map2.foo, 7);
85 EXPECT_EQ(map2.bar, 9);
86 }
87
88
89 //
90 // Test writing then reading back a sequence of mappings
91 //
TEST(YAMLIO,TestSequenceMapWriteAndRead)92 TEST(YAMLIO, TestSequenceMapWriteAndRead) {
93 std::string intermediate;
94 {
95 FooBar entry1;
96 entry1.foo = 10;
97 entry1.bar = -3;
98 FooBar entry2;
99 entry2.foo = 257;
100 entry2.bar = 0;
101 FooBarSequence seq;
102 seq.push_back(entry1);
103 seq.push_back(entry2);
104
105 llvm::raw_string_ostream ostr(intermediate);
106 Output yout(ostr);
107 yout << seq;
108 }
109
110 {
111 Input yin(intermediate);
112 FooBarSequence seq2;
113 yin >> seq2;
114
115 EXPECT_FALSE(yin.error());
116 EXPECT_EQ(seq2.size(), 2UL);
117 FooBar& map1 = seq2[0];
118 FooBar& map2 = seq2[1];
119 EXPECT_EQ(map1.foo, 10);
120 EXPECT_EQ(map1.bar, -3);
121 EXPECT_EQ(map2.foo, 257);
122 EXPECT_EQ(map2.bar, 0);
123 }
124 }
125
126
127 //===----------------------------------------------------------------------===//
128 // Test built-in types
129 //===----------------------------------------------------------------------===//
130
131 struct BuiltInTypes {
132 llvm::StringRef str;
133 uint64_t u64;
134 uint32_t u32;
135 uint16_t u16;
136 uint8_t u8;
137 bool b;
138 int64_t s64;
139 int32_t s32;
140 int16_t s16;
141 int8_t s8;
142 float f;
143 double d;
144 Hex8 h8;
145 Hex16 h16;
146 Hex32 h32;
147 Hex64 h64;
148 };
149
150 namespace llvm {
151 namespace yaml {
152 template <>
153 struct MappingTraits<BuiltInTypes> {
mappingllvm::yaml::MappingTraits154 static void mapping(IO &io, BuiltInTypes& bt) {
155 io.mapRequired("str", bt.str);
156 io.mapRequired("u64", bt.u64);
157 io.mapRequired("u32", bt.u32);
158 io.mapRequired("u16", bt.u16);
159 io.mapRequired("u8", bt.u8);
160 io.mapRequired("b", bt.b);
161 io.mapRequired("s64", bt.s64);
162 io.mapRequired("s32", bt.s32);
163 io.mapRequired("s16", bt.s16);
164 io.mapRequired("s8", bt.s8);
165 io.mapRequired("f", bt.f);
166 io.mapRequired("d", bt.d);
167 io.mapRequired("h8", bt.h8);
168 io.mapRequired("h16", bt.h16);
169 io.mapRequired("h32", bt.h32);
170 io.mapRequired("h64", bt.h64);
171 }
172 };
173 }
174 }
175
176
177 //
178 // Test the reading of all built-in scalar conversions
179 //
TEST(YAMLIO,TestReadBuiltInTypes)180 TEST(YAMLIO, TestReadBuiltInTypes) {
181 BuiltInTypes map;
182 Input yin("---\n"
183 "str: hello there\n"
184 "u64: 5000000000\n"
185 "u32: 4000000000\n"
186 "u16: 65000\n"
187 "u8: 255\n"
188 "b: false\n"
189 "s64: -5000000000\n"
190 "s32: -2000000000\n"
191 "s16: -32000\n"
192 "s8: -127\n"
193 "f: 137.125\n"
194 "d: -2.8625\n"
195 "h8: 0xFF\n"
196 "h16: 0x8765\n"
197 "h32: 0xFEDCBA98\n"
198 "h64: 0xFEDCBA9876543210\n"
199 "...\n");
200 yin >> map;
201
202 EXPECT_FALSE(yin.error());
203 EXPECT_TRUE(map.str.equals("hello there"));
204 EXPECT_EQ(map.u64, 5000000000ULL);
205 EXPECT_EQ(map.u32, 4000000000U);
206 EXPECT_EQ(map.u16, 65000);
207 EXPECT_EQ(map.u8, 255);
208 EXPECT_EQ(map.b, false);
209 EXPECT_EQ(map.s64, -5000000000LL);
210 EXPECT_EQ(map.s32, -2000000000L);
211 EXPECT_EQ(map.s16, -32000);
212 EXPECT_EQ(map.s8, -127);
213 EXPECT_EQ(map.f, 137.125);
214 EXPECT_EQ(map.d, -2.8625);
215 EXPECT_EQ(map.h8, Hex8(255));
216 EXPECT_EQ(map.h16, Hex16(0x8765));
217 EXPECT_EQ(map.h32, Hex32(0xFEDCBA98));
218 EXPECT_EQ(map.h64, Hex64(0xFEDCBA9876543210LL));
219 }
220
221
222 //
223 // Test writing then reading back all built-in scalar types
224 //
TEST(YAMLIO,TestReadWriteBuiltInTypes)225 TEST(YAMLIO, TestReadWriteBuiltInTypes) {
226 std::string intermediate;
227 {
228 BuiltInTypes map;
229 map.str = "one two";
230 map.u64 = 6000000000ULL;
231 map.u32 = 3000000000U;
232 map.u16 = 50000;
233 map.u8 = 254;
234 map.b = true;
235 map.s64 = -6000000000LL;
236 map.s32 = -2000000000;
237 map.s16 = -32000;
238 map.s8 = -128;
239 map.f = 3.25;
240 map.d = -2.8625;
241 map.h8 = 254;
242 map.h16 = 50000;
243 map.h32 = 3000000000U;
244 map.h64 = 6000000000LL;
245
246 llvm::raw_string_ostream ostr(intermediate);
247 Output yout(ostr);
248 yout << map;
249 }
250
251 {
252 Input yin(intermediate);
253 BuiltInTypes map;
254 yin >> map;
255
256 EXPECT_FALSE(yin.error());
257 EXPECT_TRUE(map.str.equals("one two"));
258 EXPECT_EQ(map.u64, 6000000000ULL);
259 EXPECT_EQ(map.u32, 3000000000U);
260 EXPECT_EQ(map.u16, 50000);
261 EXPECT_EQ(map.u8, 254);
262 EXPECT_EQ(map.b, true);
263 EXPECT_EQ(map.s64, -6000000000LL);
264 EXPECT_EQ(map.s32, -2000000000L);
265 EXPECT_EQ(map.s16, -32000);
266 EXPECT_EQ(map.s8, -128);
267 EXPECT_EQ(map.f, 3.25);
268 EXPECT_EQ(map.d, -2.8625);
269 EXPECT_EQ(map.h8, Hex8(254));
270 EXPECT_EQ(map.h16, Hex16(50000));
271 EXPECT_EQ(map.h32, Hex32(3000000000U));
272 EXPECT_EQ(map.h64, Hex64(6000000000LL));
273 }
274 }
275
276
277
278 //===----------------------------------------------------------------------===//
279 // Test ScalarEnumerationTraits
280 //===----------------------------------------------------------------------===//
281
282 enum Colors {
283 cRed,
284 cBlue,
285 cGreen,
286 cYellow
287 };
288
289 struct ColorMap {
290 Colors c1;
291 Colors c2;
292 Colors c3;
293 Colors c4;
294 Colors c5;
295 Colors c6;
296 };
297
298 namespace llvm {
299 namespace yaml {
300 template <>
301 struct ScalarEnumerationTraits<Colors> {
enumerationllvm::yaml::ScalarEnumerationTraits302 static void enumeration(IO &io, Colors &value) {
303 io.enumCase(value, "red", cRed);
304 io.enumCase(value, "blue", cBlue);
305 io.enumCase(value, "green", cGreen);
306 io.enumCase(value, "yellow",cYellow);
307 }
308 };
309 template <>
310 struct MappingTraits<ColorMap> {
mappingllvm::yaml::MappingTraits311 static void mapping(IO &io, ColorMap& c) {
312 io.mapRequired("c1", c.c1);
313 io.mapRequired("c2", c.c2);
314 io.mapRequired("c3", c.c3);
315 io.mapOptional("c4", c.c4, cBlue); // supplies default
316 io.mapOptional("c5", c.c5, cYellow); // supplies default
317 io.mapOptional("c6", c.c6, cRed); // supplies default
318 }
319 };
320 }
321 }
322
323
324 //
325 // Test reading enumerated scalars
326 //
TEST(YAMLIO,TestEnumRead)327 TEST(YAMLIO, TestEnumRead) {
328 ColorMap map;
329 Input yin("---\n"
330 "c1: blue\n"
331 "c2: red\n"
332 "c3: green\n"
333 "c5: yellow\n"
334 "...\n");
335 yin >> map;
336
337 EXPECT_FALSE(yin.error());
338 EXPECT_EQ(cBlue, map.c1);
339 EXPECT_EQ(cRed, map.c2);
340 EXPECT_EQ(cGreen, map.c3);
341 EXPECT_EQ(cBlue, map.c4); // tests default
342 EXPECT_EQ(cYellow,map.c5); // tests overridden
343 EXPECT_EQ(cRed, map.c6); // tests default
344 }
345
346
347
348 //===----------------------------------------------------------------------===//
349 // Test ScalarBitSetTraits
350 //===----------------------------------------------------------------------===//
351
352 enum MyFlags {
353 flagNone = 0,
354 flagBig = 1 << 0,
355 flagFlat = 1 << 1,
356 flagRound = 1 << 2,
357 flagPointy = 1 << 3
358 };
operator |(MyFlags a,MyFlags b)359 inline MyFlags operator|(MyFlags a, MyFlags b) {
360 return static_cast<MyFlags>(
361 static_cast<uint32_t>(a) | static_cast<uint32_t>(b));
362 }
363
364 struct FlagsMap {
365 MyFlags f1;
366 MyFlags f2;
367 MyFlags f3;
368 MyFlags f4;
369 };
370
371
372 namespace llvm {
373 namespace yaml {
374 template <>
375 struct ScalarBitSetTraits<MyFlags> {
bitsetllvm::yaml::ScalarBitSetTraits376 static void bitset(IO &io, MyFlags &value) {
377 io.bitSetCase(value, "big", flagBig);
378 io.bitSetCase(value, "flat", flagFlat);
379 io.bitSetCase(value, "round", flagRound);
380 io.bitSetCase(value, "pointy",flagPointy);
381 }
382 };
383 template <>
384 struct MappingTraits<FlagsMap> {
mappingllvm::yaml::MappingTraits385 static void mapping(IO &io, FlagsMap& c) {
386 io.mapRequired("f1", c.f1);
387 io.mapRequired("f2", c.f2);
388 io.mapRequired("f3", c.f3);
389 io.mapOptional("f4", c.f4, MyFlags(flagRound));
390 }
391 };
392 }
393 }
394
395
396 //
397 // Test reading flow sequence representing bit-mask values
398 //
TEST(YAMLIO,TestFlagsRead)399 TEST(YAMLIO, TestFlagsRead) {
400 FlagsMap map;
401 Input yin("---\n"
402 "f1: [ big ]\n"
403 "f2: [ round, flat ]\n"
404 "f3: []\n"
405 "...\n");
406 yin >> map;
407
408 EXPECT_FALSE(yin.error());
409 EXPECT_EQ(flagBig, map.f1);
410 EXPECT_EQ(flagRound|flagFlat, map.f2);
411 EXPECT_EQ(flagNone, map.f3); // check empty set
412 EXPECT_EQ(flagRound, map.f4); // check optional key
413 }
414
415
416 //
417 // Test writing then reading back bit-mask values
418 //
TEST(YAMLIO,TestReadWriteFlags)419 TEST(YAMLIO, TestReadWriteFlags) {
420 std::string intermediate;
421 {
422 FlagsMap map;
423 map.f1 = flagBig;
424 map.f2 = flagRound | flagFlat;
425 map.f3 = flagNone;
426 map.f4 = flagNone;
427
428 llvm::raw_string_ostream ostr(intermediate);
429 Output yout(ostr);
430 yout << map;
431 }
432
433 {
434 Input yin(intermediate);
435 FlagsMap map2;
436 yin >> map2;
437
438 EXPECT_FALSE(yin.error());
439 EXPECT_EQ(flagBig, map2.f1);
440 EXPECT_EQ(flagRound|flagFlat, map2.f2);
441 EXPECT_EQ(flagNone, map2.f3);
442 //EXPECT_EQ(flagRound, map2.f4); // check optional key
443 }
444 }
445
446
447
448 //===----------------------------------------------------------------------===//
449 // Test ScalarTraits
450 //===----------------------------------------------------------------------===//
451
452 struct MyCustomType {
453 int length;
454 int width;
455 };
456
457 struct MyCustomTypeMap {
458 MyCustomType f1;
459 MyCustomType f2;
460 int f3;
461 };
462
463
464 namespace llvm {
465 namespace yaml {
466 template <>
467 struct MappingTraits<MyCustomTypeMap> {
mappingllvm::yaml::MappingTraits468 static void mapping(IO &io, MyCustomTypeMap& s) {
469 io.mapRequired("f1", s.f1);
470 io.mapRequired("f2", s.f2);
471 io.mapRequired("f3", s.f3);
472 }
473 };
474 // MyCustomType is formatted as a yaml scalar. A value of
475 // {length=3, width=4} would be represented in yaml as "3 by 4".
476 template<>
477 struct ScalarTraits<MyCustomType> {
outputllvm::yaml::ScalarTraits478 static void output(const MyCustomType &value, void* ctxt, llvm::raw_ostream &out) {
479 out << llvm::format("%d by %d", value.length, value.width);
480 }
inputllvm::yaml::ScalarTraits481 static StringRef input(StringRef scalar, void* ctxt, MyCustomType &value) {
482 size_t byStart = scalar.find("by");
483 if ( byStart != StringRef::npos ) {
484 StringRef lenStr = scalar.slice(0, byStart);
485 lenStr = lenStr.rtrim();
486 if ( lenStr.getAsInteger(0, value.length) ) {
487 return "malformed length";
488 }
489 StringRef widthStr = scalar.drop_front(byStart+2);
490 widthStr = widthStr.ltrim();
491 if ( widthStr.getAsInteger(0, value.width) ) {
492 return "malformed width";
493 }
494 return StringRef();
495 }
496 else {
497 return "malformed by";
498 }
499 }
500 };
501 }
502 }
503
504
505 //
506 // Test writing then reading back custom values
507 //
TEST(YAMLIO,TestReadWriteMyCustomType)508 TEST(YAMLIO, TestReadWriteMyCustomType) {
509 std::string intermediate;
510 {
511 MyCustomTypeMap map;
512 map.f1.length = 1;
513 map.f1.width = 4;
514 map.f2.length = 100;
515 map.f2.width = 400;
516 map.f3 = 10;
517
518 llvm::raw_string_ostream ostr(intermediate);
519 Output yout(ostr);
520 yout << map;
521 }
522
523 {
524 Input yin(intermediate);
525 MyCustomTypeMap map2;
526 yin >> map2;
527
528 EXPECT_FALSE(yin.error());
529 EXPECT_EQ(1, map2.f1.length);
530 EXPECT_EQ(4, map2.f1.width);
531 EXPECT_EQ(100, map2.f2.length);
532 EXPECT_EQ(400, map2.f2.width);
533 EXPECT_EQ(10, map2.f3);
534 }
535 }
536
537
538 //===----------------------------------------------------------------------===//
539 // Test flow sequences
540 //===----------------------------------------------------------------------===//
541
542 LLVM_YAML_STRONG_TYPEDEF(int, MyNumber)
543 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(MyNumber)
544 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::StringRef)
545
546 namespace llvm {
547 namespace yaml {
548 template<>
549 struct ScalarTraits<MyNumber> {
outputllvm::yaml::ScalarTraits550 static void output(const MyNumber &value, void *, llvm::raw_ostream &out) {
551 out << value;
552 }
553
inputllvm::yaml::ScalarTraits554 static StringRef input(StringRef scalar, void *, MyNumber &value) {
555 long long n;
556 if ( getAsSignedInteger(scalar, 0, n) )
557 return "invalid number";
558 value = n;
559 return StringRef();
560 }
561 };
562 }
563 }
564
565 struct NameAndNumbers {
566 llvm::StringRef name;
567 std::vector<llvm::StringRef> strings;
568 std::vector<MyNumber> single;
569 std::vector<MyNumber> numbers;
570 };
571
572 namespace llvm {
573 namespace yaml {
574 template <>
575 struct MappingTraits<NameAndNumbers> {
mappingllvm::yaml::MappingTraits576 static void mapping(IO &io, NameAndNumbers& nn) {
577 io.mapRequired("name", nn.name);
578 io.mapRequired("strings", nn.strings);
579 io.mapRequired("single", nn.single);
580 io.mapRequired("numbers", nn.numbers);
581 }
582 };
583 }
584 }
585
586
587 //
588 // Test writing then reading back custom values
589 //
TEST(YAMLIO,TestReadWriteMyFlowSequence)590 TEST(YAMLIO, TestReadWriteMyFlowSequence) {
591 std::string intermediate;
592 {
593 NameAndNumbers map;
594 map.name = "hello";
595 map.strings.push_back(llvm::StringRef("one"));
596 map.strings.push_back(llvm::StringRef("two"));
597 map.single.push_back(1);
598 map.numbers.push_back(10);
599 map.numbers.push_back(-30);
600 map.numbers.push_back(1024);
601
602 llvm::raw_string_ostream ostr(intermediate);
603 Output yout(ostr);
604 yout << map;
605
606 // Verify sequences were written in flow style
607 ostr.flush();
608 llvm::StringRef flowOut(intermediate);
609 EXPECT_NE(llvm::StringRef::npos, flowOut.find("one, two"));
610 EXPECT_NE(llvm::StringRef::npos, flowOut.find("10, -30, 1024"));
611 }
612
613 {
614 Input yin(intermediate);
615 NameAndNumbers map2;
616 yin >> map2;
617
618 EXPECT_FALSE(yin.error());
619 EXPECT_TRUE(map2.name.equals("hello"));
620 EXPECT_EQ(map2.strings.size(), 2UL);
621 EXPECT_TRUE(map2.strings[0].equals("one"));
622 EXPECT_TRUE(map2.strings[1].equals("two"));
623 EXPECT_EQ(map2.single.size(), 1UL);
624 EXPECT_EQ(1, map2.single[0]);
625 EXPECT_EQ(map2.numbers.size(), 3UL);
626 EXPECT_EQ(10, map2.numbers[0]);
627 EXPECT_EQ(-30, map2.numbers[1]);
628 EXPECT_EQ(1024, map2.numbers[2]);
629 }
630 }
631
632
633 //===----------------------------------------------------------------------===//
634 // Test normalizing/denormalizing
635 //===----------------------------------------------------------------------===//
636
637 LLVM_YAML_STRONG_TYPEDEF(uint32_t, TotalSeconds)
638
639 typedef std::vector<TotalSeconds> SecondsSequence;
640
641 LLVM_YAML_IS_SEQUENCE_VECTOR(TotalSeconds)
642
643
644 namespace llvm {
645 namespace yaml {
646 template <>
647 struct MappingTraits<TotalSeconds> {
648
649 class NormalizedSeconds {
650 public:
NormalizedSeconds(IO & io)651 NormalizedSeconds(IO &io)
652 : hours(0), minutes(0), seconds(0) {
653 }
NormalizedSeconds(IO &,TotalSeconds & secs)654 NormalizedSeconds(IO &, TotalSeconds &secs)
655 : hours(secs/3600),
656 minutes((secs - (hours*3600))/60),
657 seconds(secs % 60) {
658 }
denormalize(IO &)659 TotalSeconds denormalize(IO &) {
660 return TotalSeconds(hours*3600 + minutes*60 + seconds);
661 }
662
663 uint32_t hours;
664 uint8_t minutes;
665 uint8_t seconds;
666 };
667
mappingllvm::yaml::MappingTraits668 static void mapping(IO &io, TotalSeconds &secs) {
669 MappingNormalization<NormalizedSeconds, TotalSeconds> keys(io, secs);
670
671 io.mapOptional("hours", keys->hours, (uint32_t)0);
672 io.mapOptional("minutes", keys->minutes, (uint8_t)0);
673 io.mapRequired("seconds", keys->seconds);
674 }
675 };
676 }
677 }
678
679
680 //
681 // Test the reading of a yaml sequence of mappings
682 //
TEST(YAMLIO,TestReadMySecondsSequence)683 TEST(YAMLIO, TestReadMySecondsSequence) {
684 SecondsSequence seq;
685 Input yin("---\n - hours: 1\n seconds: 5\n - seconds: 59\n...\n");
686 yin >> seq;
687
688 EXPECT_FALSE(yin.error());
689 EXPECT_EQ(seq.size(), 2UL);
690 EXPECT_EQ(seq[0], 3605U);
691 EXPECT_EQ(seq[1], 59U);
692 }
693
694
695 //
696 // Test writing then reading back custom values
697 //
TEST(YAMLIO,TestReadWriteMySecondsSequence)698 TEST(YAMLIO, TestReadWriteMySecondsSequence) {
699 std::string intermediate;
700 {
701 SecondsSequence seq;
702 seq.push_back(4000);
703 seq.push_back(500);
704 seq.push_back(59);
705
706 llvm::raw_string_ostream ostr(intermediate);
707 Output yout(ostr);
708 yout << seq;
709 }
710 {
711 Input yin(intermediate);
712 SecondsSequence seq2;
713 yin >> seq2;
714
715 EXPECT_FALSE(yin.error());
716 EXPECT_EQ(seq2.size(), 3UL);
717 EXPECT_EQ(seq2[0], 4000U);
718 EXPECT_EQ(seq2[1], 500U);
719 EXPECT_EQ(seq2[2], 59U);
720 }
721 }
722
723
724 //===----------------------------------------------------------------------===//
725 // Test dynamic typing
726 //===----------------------------------------------------------------------===//
727
728 enum AFlags {
729 a1,
730 a2,
731 a3
732 };
733
734 enum BFlags {
735 b1,
736 b2,
737 b3
738 };
739
740 enum Kind {
741 kindA,
742 kindB
743 };
744
745 struct KindAndFlags {
KindAndFlagsKindAndFlags746 KindAndFlags() : kind(kindA), flags(0) { }
KindAndFlagsKindAndFlags747 KindAndFlags(Kind k, uint32_t f) : kind(k), flags(f) { }
748 Kind kind;
749 uint32_t flags;
750 };
751
752 typedef std::vector<KindAndFlags> KindAndFlagsSequence;
753
754 LLVM_YAML_IS_SEQUENCE_VECTOR(KindAndFlags)
755
756 namespace llvm {
757 namespace yaml {
758 template <>
759 struct ScalarEnumerationTraits<AFlags> {
enumerationllvm::yaml::ScalarEnumerationTraits760 static void enumeration(IO &io, AFlags &value) {
761 io.enumCase(value, "a1", a1);
762 io.enumCase(value, "a2", a2);
763 io.enumCase(value, "a3", a3);
764 }
765 };
766 template <>
767 struct ScalarEnumerationTraits<BFlags> {
enumerationllvm::yaml::ScalarEnumerationTraits768 static void enumeration(IO &io, BFlags &value) {
769 io.enumCase(value, "b1", b1);
770 io.enumCase(value, "b2", b2);
771 io.enumCase(value, "b3", b3);
772 }
773 };
774 template <>
775 struct ScalarEnumerationTraits<Kind> {
enumerationllvm::yaml::ScalarEnumerationTraits776 static void enumeration(IO &io, Kind &value) {
777 io.enumCase(value, "A", kindA);
778 io.enumCase(value, "B", kindB);
779 }
780 };
781 template <>
782 struct MappingTraits<KindAndFlags> {
mappingllvm::yaml::MappingTraits783 static void mapping(IO &io, KindAndFlags& kf) {
784 io.mapRequired("kind", kf.kind);
785 // Type of "flags" field varies depending on "kind" field.
786 // Use memcpy here to avoid breaking strict aliasing rules.
787 if (kf.kind == kindA) {
788 AFlags aflags = static_cast<AFlags>(kf.flags);
789 io.mapRequired("flags", aflags);
790 kf.flags = aflags;
791 } else {
792 BFlags bflags = static_cast<BFlags>(kf.flags);
793 io.mapRequired("flags", bflags);
794 kf.flags = bflags;
795 }
796 }
797 };
798 }
799 }
800
801
802 //
803 // Test the reading of a yaml sequence dynamic types
804 //
TEST(YAMLIO,TestReadKindAndFlagsSequence)805 TEST(YAMLIO, TestReadKindAndFlagsSequence) {
806 KindAndFlagsSequence seq;
807 Input yin("---\n - kind: A\n flags: a2\n - kind: B\n flags: b1\n...\n");
808 yin >> seq;
809
810 EXPECT_FALSE(yin.error());
811 EXPECT_EQ(seq.size(), 2UL);
812 EXPECT_EQ(seq[0].kind, kindA);
813 EXPECT_EQ(seq[0].flags, (uint32_t)a2);
814 EXPECT_EQ(seq[1].kind, kindB);
815 EXPECT_EQ(seq[1].flags, (uint32_t)b1);
816 }
817
818 //
819 // Test writing then reading back dynamic types
820 //
TEST(YAMLIO,TestReadWriteKindAndFlagsSequence)821 TEST(YAMLIO, TestReadWriteKindAndFlagsSequence) {
822 std::string intermediate;
823 {
824 KindAndFlagsSequence seq;
825 seq.push_back(KindAndFlags(kindA,a1));
826 seq.push_back(KindAndFlags(kindB,b1));
827 seq.push_back(KindAndFlags(kindA,a2));
828 seq.push_back(KindAndFlags(kindB,b2));
829 seq.push_back(KindAndFlags(kindA,a3));
830
831 llvm::raw_string_ostream ostr(intermediate);
832 Output yout(ostr);
833 yout << seq;
834 }
835 {
836 Input yin(intermediate);
837 KindAndFlagsSequence seq2;
838 yin >> seq2;
839
840 EXPECT_FALSE(yin.error());
841 EXPECT_EQ(seq2.size(), 5UL);
842 EXPECT_EQ(seq2[0].kind, kindA);
843 EXPECT_EQ(seq2[0].flags, (uint32_t)a1);
844 EXPECT_EQ(seq2[1].kind, kindB);
845 EXPECT_EQ(seq2[1].flags, (uint32_t)b1);
846 EXPECT_EQ(seq2[2].kind, kindA);
847 EXPECT_EQ(seq2[2].flags, (uint32_t)a2);
848 EXPECT_EQ(seq2[3].kind, kindB);
849 EXPECT_EQ(seq2[3].flags, (uint32_t)b2);
850 EXPECT_EQ(seq2[4].kind, kindA);
851 EXPECT_EQ(seq2[4].flags, (uint32_t)a3);
852 }
853 }
854
855
856 //===----------------------------------------------------------------------===//
857 // Test document list
858 //===----------------------------------------------------------------------===//
859
860 struct FooBarMap {
861 int foo;
862 int bar;
863 };
864 typedef std::vector<FooBarMap> FooBarMapDocumentList;
865
866 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(FooBarMap)
867
868
869 namespace llvm {
870 namespace yaml {
871 template <>
872 struct MappingTraits<FooBarMap> {
mappingllvm::yaml::MappingTraits873 static void mapping(IO &io, FooBarMap& fb) {
874 io.mapRequired("foo", fb.foo);
875 io.mapRequired("bar", fb.bar);
876 }
877 };
878 }
879 }
880
881
882 //
883 // Test the reading of a yaml mapping
884 //
TEST(YAMLIO,TestDocRead)885 TEST(YAMLIO, TestDocRead) {
886 FooBarMap doc;
887 Input yin("---\nfoo: 3\nbar: 5\n...\n");
888 yin >> doc;
889
890 EXPECT_FALSE(yin.error());
891 EXPECT_EQ(doc.foo, 3);
892 EXPECT_EQ(doc.bar,5);
893 }
894
895
896
897 //
898 // Test writing then reading back a sequence of mappings
899 //
TEST(YAMLIO,TestSequenceDocListWriteAndRead)900 TEST(YAMLIO, TestSequenceDocListWriteAndRead) {
901 std::string intermediate;
902 {
903 FooBarMap doc1;
904 doc1.foo = 10;
905 doc1.bar = -3;
906 FooBarMap doc2;
907 doc2.foo = 257;
908 doc2.bar = 0;
909 std::vector<FooBarMap> docList;
910 docList.push_back(doc1);
911 docList.push_back(doc2);
912
913 llvm::raw_string_ostream ostr(intermediate);
914 Output yout(ostr);
915 yout << docList;
916 }
917
918
919 {
920 Input yin(intermediate);
921 std::vector<FooBarMap> docList2;
922 yin >> docList2;
923
924 EXPECT_FALSE(yin.error());
925 EXPECT_EQ(docList2.size(), 2UL);
926 FooBarMap& map1 = docList2[0];
927 FooBarMap& map2 = docList2[1];
928 EXPECT_EQ(map1.foo, 10);
929 EXPECT_EQ(map1.bar, -3);
930 EXPECT_EQ(map2.foo, 257);
931 EXPECT_EQ(map2.bar, 0);
932 }
933 }
934
935
936 //===----------------------------------------------------------------------===//
937 // Test error handling
938 //===----------------------------------------------------------------------===//
939
940
941
suppressErrorMessages(const llvm::SMDiagnostic &,void *)942 static void suppressErrorMessages(const llvm::SMDiagnostic &, void *) {
943 }
944
945
946 //
947 // Test error handling of unknown enumerated scalar
948 //
TEST(YAMLIO,TestColorsReadError)949 TEST(YAMLIO, TestColorsReadError) {
950 ColorMap map;
951 Input yin("---\n"
952 "c1: blue\n"
953 "c2: purple\n"
954 "c3: green\n"
955 "...\n");
956 yin.setDiagHandler(suppressErrorMessages);
957 yin >> map;
958 EXPECT_TRUE(yin.error());
959 }
960
961
962 //
963 // Test error handling of flow sequence with unknown value
964 //
TEST(YAMLIO,TestFlagsReadError)965 TEST(YAMLIO, TestFlagsReadError) {
966 FlagsMap map;
967 Input yin("---\n"
968 "f1: [ big ]\n"
969 "f2: [ round, hollow ]\n"
970 "f3: []\n"
971 "...\n");
972 yin.setDiagHandler(suppressErrorMessages);
973 yin >> map;
974
975 EXPECT_TRUE(yin.error());
976 }
977
978
979 //
980 // Test error handling reading built-in uint8_t type
981 //
982 LLVM_YAML_IS_SEQUENCE_VECTOR(uint8_t)
TEST(YAMLIO,TestReadBuiltInTypesUint8Error)983 TEST(YAMLIO, TestReadBuiltInTypesUint8Error) {
984 std::vector<uint8_t> seq;
985 Input yin("---\n"
986 "- 255\n"
987 "- 0\n"
988 "- 257\n"
989 "...\n");
990 yin.setDiagHandler(suppressErrorMessages);
991 yin >> seq;
992
993 EXPECT_TRUE(yin.error());
994 }
995
996
997 //
998 // Test error handling reading built-in uint16_t type
999 //
1000 LLVM_YAML_IS_SEQUENCE_VECTOR(uint16_t)
TEST(YAMLIO,TestReadBuiltInTypesUint16Error)1001 TEST(YAMLIO, TestReadBuiltInTypesUint16Error) {
1002 std::vector<uint16_t> seq;
1003 Input yin("---\n"
1004 "- 65535\n"
1005 "- 0\n"
1006 "- 66000\n"
1007 "...\n");
1008 yin.setDiagHandler(suppressErrorMessages);
1009 yin >> seq;
1010
1011 EXPECT_TRUE(yin.error());
1012 }
1013
1014
1015 //
1016 // Test error handling reading built-in uint32_t type
1017 //
1018 LLVM_YAML_IS_SEQUENCE_VECTOR(uint32_t)
TEST(YAMLIO,TestReadBuiltInTypesUint32Error)1019 TEST(YAMLIO, TestReadBuiltInTypesUint32Error) {
1020 std::vector<uint32_t> seq;
1021 Input yin("---\n"
1022 "- 4000000000\n"
1023 "- 0\n"
1024 "- 5000000000\n"
1025 "...\n");
1026 yin.setDiagHandler(suppressErrorMessages);
1027 yin >> seq;
1028
1029 EXPECT_TRUE(yin.error());
1030 }
1031
1032
1033 //
1034 // Test error handling reading built-in uint64_t type
1035 //
1036 LLVM_YAML_IS_SEQUENCE_VECTOR(uint64_t)
TEST(YAMLIO,TestReadBuiltInTypesUint64Error)1037 TEST(YAMLIO, TestReadBuiltInTypesUint64Error) {
1038 std::vector<uint64_t> seq;
1039 Input yin("---\n"
1040 "- 18446744073709551615\n"
1041 "- 0\n"
1042 "- 19446744073709551615\n"
1043 "...\n");
1044 yin.setDiagHandler(suppressErrorMessages);
1045 yin >> seq;
1046
1047 EXPECT_TRUE(yin.error());
1048 }
1049
1050
1051 //
1052 // Test error handling reading built-in int8_t type
1053 //
1054 LLVM_YAML_IS_SEQUENCE_VECTOR(int8_t)
TEST(YAMLIO,TestReadBuiltInTypesint8OverError)1055 TEST(YAMLIO, TestReadBuiltInTypesint8OverError) {
1056 std::vector<int8_t> seq;
1057 Input yin("---\n"
1058 "- -128\n"
1059 "- 0\n"
1060 "- 127\n"
1061 "- 128\n"
1062 "...\n");
1063 yin.setDiagHandler(suppressErrorMessages);
1064 yin >> seq;
1065
1066 EXPECT_TRUE(yin.error());
1067 }
1068
1069 //
1070 // Test error handling reading built-in int8_t type
1071 //
TEST(YAMLIO,TestReadBuiltInTypesint8UnderError)1072 TEST(YAMLIO, TestReadBuiltInTypesint8UnderError) {
1073 std::vector<int8_t> seq;
1074 Input yin("---\n"
1075 "- -128\n"
1076 "- 0\n"
1077 "- 127\n"
1078 "- -129\n"
1079 "...\n");
1080 yin.setDiagHandler(suppressErrorMessages);
1081 yin >> seq;
1082
1083 EXPECT_TRUE(yin.error());
1084 }
1085
1086
1087 //
1088 // Test error handling reading built-in int16_t type
1089 //
1090 LLVM_YAML_IS_SEQUENCE_VECTOR(int16_t)
TEST(YAMLIO,TestReadBuiltInTypesint16UnderError)1091 TEST(YAMLIO, TestReadBuiltInTypesint16UnderError) {
1092 std::vector<int16_t> seq;
1093 Input yin("---\n"
1094 "- 32767\n"
1095 "- 0\n"
1096 "- -32768\n"
1097 "- -32769\n"
1098 "...\n");
1099 yin.setDiagHandler(suppressErrorMessages);
1100 yin >> seq;
1101
1102 EXPECT_TRUE(yin.error());
1103 }
1104
1105
1106 //
1107 // Test error handling reading built-in int16_t type
1108 //
TEST(YAMLIO,TestReadBuiltInTypesint16OverError)1109 TEST(YAMLIO, TestReadBuiltInTypesint16OverError) {
1110 std::vector<int16_t> seq;
1111 Input yin("---\n"
1112 "- 32767\n"
1113 "- 0\n"
1114 "- -32768\n"
1115 "- 32768\n"
1116 "...\n");
1117 yin.setDiagHandler(suppressErrorMessages);
1118 yin >> seq;
1119
1120 EXPECT_TRUE(yin.error());
1121 }
1122
1123
1124 //
1125 // Test error handling reading built-in int32_t type
1126 //
1127 LLVM_YAML_IS_SEQUENCE_VECTOR(int32_t)
TEST(YAMLIO,TestReadBuiltInTypesint32UnderError)1128 TEST(YAMLIO, TestReadBuiltInTypesint32UnderError) {
1129 std::vector<int32_t> seq;
1130 Input yin("---\n"
1131 "- 2147483647\n"
1132 "- 0\n"
1133 "- -2147483648\n"
1134 "- -2147483649\n"
1135 "...\n");
1136 yin.setDiagHandler(suppressErrorMessages);
1137 yin >> seq;
1138
1139 EXPECT_TRUE(yin.error());
1140 }
1141
1142 //
1143 // Test error handling reading built-in int32_t type
1144 //
TEST(YAMLIO,TestReadBuiltInTypesint32OverError)1145 TEST(YAMLIO, TestReadBuiltInTypesint32OverError) {
1146 std::vector<int32_t> seq;
1147 Input yin("---\n"
1148 "- 2147483647\n"
1149 "- 0\n"
1150 "- -2147483648\n"
1151 "- 2147483649\n"
1152 "...\n");
1153 yin.setDiagHandler(suppressErrorMessages);
1154 yin >> seq;
1155
1156 EXPECT_TRUE(yin.error());
1157 }
1158
1159
1160 //
1161 // Test error handling reading built-in int64_t type
1162 //
1163 LLVM_YAML_IS_SEQUENCE_VECTOR(int64_t)
TEST(YAMLIO,TestReadBuiltInTypesint64UnderError)1164 TEST(YAMLIO, TestReadBuiltInTypesint64UnderError) {
1165 std::vector<int64_t> seq;
1166 Input yin("---\n"
1167 "- -9223372036854775808\n"
1168 "- 0\n"
1169 "- 9223372036854775807\n"
1170 "- -9223372036854775809\n"
1171 "...\n");
1172 yin.setDiagHandler(suppressErrorMessages);
1173 yin >> seq;
1174
1175 EXPECT_TRUE(yin.error());
1176 }
1177
1178 //
1179 // Test error handling reading built-in int64_t type
1180 //
TEST(YAMLIO,TestReadBuiltInTypesint64OverError)1181 TEST(YAMLIO, TestReadBuiltInTypesint64OverError) {
1182 std::vector<int64_t> seq;
1183 Input yin("---\n"
1184 "- -9223372036854775808\n"
1185 "- 0\n"
1186 "- 9223372036854775807\n"
1187 "- 9223372036854775809\n"
1188 "...\n");
1189 yin.setDiagHandler(suppressErrorMessages);
1190 yin >> seq;
1191
1192 EXPECT_TRUE(yin.error());
1193 }
1194
1195 //
1196 // Test error handling reading built-in float type
1197 //
1198 LLVM_YAML_IS_SEQUENCE_VECTOR(float)
TEST(YAMLIO,TestReadBuiltInTypesFloatError)1199 TEST(YAMLIO, TestReadBuiltInTypesFloatError) {
1200 std::vector<float> seq;
1201 Input yin("---\n"
1202 "- 0.0\n"
1203 "- 1000.1\n"
1204 "- -123.456\n"
1205 "- 1.2.3\n"
1206 "...\n");
1207 yin.setDiagHandler(suppressErrorMessages);
1208 yin >> seq;
1209
1210 EXPECT_TRUE(yin.error());
1211 }
1212
1213 //
1214 // Test error handling reading built-in float type
1215 //
1216 LLVM_YAML_IS_SEQUENCE_VECTOR(double)
TEST(YAMLIO,TestReadBuiltInTypesDoubleError)1217 TEST(YAMLIO, TestReadBuiltInTypesDoubleError) {
1218 std::vector<double> seq;
1219 Input yin("---\n"
1220 "- 0.0\n"
1221 "- 1000.1\n"
1222 "- -123.456\n"
1223 "- 1.2.3\n"
1224 "...\n");
1225 yin.setDiagHandler(suppressErrorMessages);
1226 yin >> seq;
1227
1228 EXPECT_TRUE(yin.error());
1229 }
1230
1231 //
1232 // Test error handling reading built-in Hex8 type
1233 //
1234 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex8)
TEST(YAMLIO,TestReadBuiltInTypesHex8Error)1235 TEST(YAMLIO, TestReadBuiltInTypesHex8Error) {
1236 std::vector<Hex8> seq;
1237 Input yin("---\n"
1238 "- 0x12\n"
1239 "- 0xFE\n"
1240 "- 0x123\n"
1241 "...\n");
1242 yin.setDiagHandler(suppressErrorMessages);
1243 yin >> seq;
1244
1245 EXPECT_TRUE(yin.error());
1246 }
1247
1248
1249 //
1250 // Test error handling reading built-in Hex16 type
1251 //
1252 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex16)
TEST(YAMLIO,TestReadBuiltInTypesHex16Error)1253 TEST(YAMLIO, TestReadBuiltInTypesHex16Error) {
1254 std::vector<Hex16> seq;
1255 Input yin("---\n"
1256 "- 0x0012\n"
1257 "- 0xFEFF\n"
1258 "- 0x12345\n"
1259 "...\n");
1260 yin.setDiagHandler(suppressErrorMessages);
1261 yin >> seq;
1262
1263 EXPECT_TRUE(yin.error());
1264 }
1265
1266 //
1267 // Test error handling reading built-in Hex32 type
1268 //
1269 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex32)
TEST(YAMLIO,TestReadBuiltInTypesHex32Error)1270 TEST(YAMLIO, TestReadBuiltInTypesHex32Error) {
1271 std::vector<Hex32> seq;
1272 Input yin("---\n"
1273 "- 0x0012\n"
1274 "- 0xFEFF0000\n"
1275 "- 0x1234556789\n"
1276 "...\n");
1277 yin.setDiagHandler(suppressErrorMessages);
1278 yin >> seq;
1279
1280 EXPECT_TRUE(yin.error());
1281 }
1282
1283 //
1284 // Test error handling reading built-in Hex64 type
1285 //
1286 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex64)
TEST(YAMLIO,TestReadBuiltInTypesHex64Error)1287 TEST(YAMLIO, TestReadBuiltInTypesHex64Error) {
1288 std::vector<Hex64> seq;
1289 Input yin("---\n"
1290 "- 0x0012\n"
1291 "- 0xFFEEDDCCBBAA9988\n"
1292 "- 0x12345567890ABCDEF0\n"
1293 "...\n");
1294 yin.setDiagHandler(suppressErrorMessages);
1295 yin >> seq;
1296
1297 EXPECT_TRUE(yin.error());
1298 }
1299
1300