0993d8c0b555e53c47ceaae5619aacade2caa5a7
[opencl/llvm.git] / unittests / Support / YAMLIOTest.cpp
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 //===----------------------------------------------------------------------===//
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"
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;
30 //===----------------------------------------------------------------------===//
31 //  Test MappingTraits
32 //===----------------------------------------------------------------------===//
34 struct FooBar {
35   int foo;
36   int bar;
37 };
38 typedef std::vector<FooBar> FooBarSequence;
40 LLVM_YAML_IS_SEQUENCE_VECTOR(FooBar)
43 namespace llvm {
44 namespace yaml {
45   template <>
46   struct MappingTraits<FooBar> {
47     static void mapping(IO &io, FooBar& fb) {
48       io.mapRequired("foo",    fb.foo);
49       io.mapRequired("bar",    fb.bar);
50     }
51   };
52 }
53 }
56 //
57 // Test the reading of a yaml mapping
58 //
59 TEST(YAMLIO, TestMapRead) {
60   FooBar doc;
61   Input yin("---\nfoo:  3\nbar:  5\n...\n");
62   yin >> doc;
64   EXPECT_FALSE(yin.error());
65   EXPECT_EQ(doc.foo, 3);
66   EXPECT_EQ(doc.bar,5);
67 }
70 //
71 // Test the reading of a yaml sequence of mappings
72 //
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;
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 }
89 //
90 // Test writing then reading back a sequence of mappings
91 //
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);
105     llvm::raw_string_ostream ostr(intermediate);
106     Output yout(ostr);
107     yout << seq;
108   }
110   {
111     Input yin(intermediate);
112     FooBarSequence seq2;
113     yin >> seq2;
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   }
127 //===----------------------------------------------------------------------===//
128 //  Test built-in types
129 //===----------------------------------------------------------------------===//
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 };
150 namespace llvm {
151 namespace yaml {
152   template <>
153   struct MappingTraits<BuiltInTypes> {
154     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   };
177 //
178 // Test the reading of all built-in scalar conversions
179 //
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;
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));
222 //
223 // Test writing then reading back all built-in scalar types
224 //
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;
246     llvm::raw_string_ostream ostr(intermediate);
247     Output yout(ostr);
248     yout << map;
249   }
251   {
252     Input yin(intermediate);
253     BuiltInTypes map;
254     yin >> map;
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   }
278 //===----------------------------------------------------------------------===//
279 //  Test ScalarEnumerationTraits
280 //===----------------------------------------------------------------------===//
282 enum Colors {
283     cRed,
284     cBlue,
285     cGreen,
286     cYellow
287 };
289 struct ColorMap {
290   Colors      c1;
291   Colors      c2;
292   Colors      c3;
293   Colors      c4;
294   Colors      c5;
295   Colors      c6;
296 };
298 namespace llvm {
299 namespace yaml {
300   template <>
301   struct ScalarEnumerationTraits<Colors> {
302     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> {
311     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   };
324 //
325 // Test reading enumerated scalars
326 //
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;
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
348 //===----------------------------------------------------------------------===//
349 //  Test ScalarBitSetTraits
350 //===----------------------------------------------------------------------===//
352 enum MyFlags {
353   flagNone    = 0,
354   flagBig     = 1 << 0,
355   flagFlat    = 1 << 1,
356   flagRound   = 1 << 2,
357   flagPointy  = 1 << 3
358 };
359 inline MyFlags operator|(MyFlags a, MyFlags b) {
360   return static_cast<MyFlags>(
361                       static_cast<uint32_t>(a) | static_cast<uint32_t>(b));
364 struct FlagsMap {
365   MyFlags     f1;
366   MyFlags     f2;
367   MyFlags     f3;
368   MyFlags     f4;
369 };
372 namespace llvm {
373 namespace yaml {
374   template <>
375   struct ScalarBitSetTraits<MyFlags> {
376     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> {
385     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   };
396 //
397 // Test reading flow sequence representing bit-mask values
398 //
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;
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
416 //
417 // Test writing then reading back bit-mask values
418 //
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;
428     llvm::raw_string_ostream ostr(intermediate);
429     Output yout(ostr);
430     yout << map;
431   }
433   {
434     Input yin(intermediate);
435     FlagsMap map2;
436     yin >> map2;
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   }
448 //===----------------------------------------------------------------------===//
449 //  Test ScalarTraits
450 //===----------------------------------------------------------------------===//
452 struct MyCustomType {
453   int length;
454   int width;
455 };
457 struct MyCustomTypeMap {
458   MyCustomType     f1;
459   MyCustomType     f2;
460   int              f3;
461 };
464 namespace llvm {
465 namespace yaml {
466   template <>
467   struct MappingTraits<MyCustomTypeMap> {
468     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> {
478     static void output(const MyCustomType &value, void* ctxt, llvm::raw_ostream &out) {
479       out << llvm::format("%d by %d", value.length, value.width);
480     }
481     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   };
505 //
506 // Test writing then reading back custom values
507 //
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;
518     llvm::raw_string_ostream ostr(intermediate);
519     Output yout(ostr);
520     yout << map;
521   }
523   {
524     Input yin(intermediate);
525     MyCustomTypeMap map2;
526     yin >> map2;
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   }
538 //===----------------------------------------------------------------------===//
539 //  Test flow sequences
540 //===----------------------------------------------------------------------===//
542 LLVM_YAML_STRONG_TYPEDEF(int, MyNumber)
543 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(MyNumber)
544 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::StringRef)
546 namespace llvm {
547 namespace yaml {
548   template<>
549   struct ScalarTraits<MyNumber> {
550     static void output(const MyNumber &value, void *, llvm::raw_ostream &out) {
551       out << value;
552     }
554     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   };
565 struct NameAndNumbers {
566   llvm::StringRef               name;
567   std::vector<llvm::StringRef>  strings;
568   std::vector<MyNumber>         single;
569   std::vector<MyNumber>         numbers;
570 };
572 namespace llvm {
573 namespace yaml {
574   template <>
575   struct MappingTraits<NameAndNumbers> {
576     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   };
587 //
588 // Test writing then reading back custom values
589 //
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);
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   }
613   {
614     Input yin(intermediate);
615     NameAndNumbers map2;
616     yin >> map2;
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   }
633 //===----------------------------------------------------------------------===//
634 //  Test normalizing/denormalizing
635 //===----------------------------------------------------------------------===//
637 LLVM_YAML_STRONG_TYPEDEF(uint32_t, TotalSeconds)
639 typedef std::vector<TotalSeconds> SecondsSequence;
641 LLVM_YAML_IS_SEQUENCE_VECTOR(TotalSeconds)
644 namespace llvm {
645 namespace yaml {
646   template <>
647   struct MappingTraits<TotalSeconds> {
649     class NormalizedSeconds {
650     public:
651       NormalizedSeconds(IO &io)
652         : hours(0), minutes(0), seconds(0) {
653       }
654       NormalizedSeconds(IO &, TotalSeconds &secs)
655         : hours(secs/3600),
656           minutes((secs - (hours*3600))/60),
657           seconds(secs % 60) {
658       }
659       TotalSeconds denormalize(IO &) {
660         return TotalSeconds(hours*3600 + minutes*60 + seconds);
661       }
663       uint32_t     hours;
664       uint8_t      minutes;
665       uint8_t      seconds;
666     };
668     static void mapping(IO &io, TotalSeconds &secs) {
669       MappingNormalization<NormalizedSeconds, TotalSeconds> keys(io, secs);
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   };
680 //
681 // Test the reading of a yaml sequence of mappings
682 //
683 TEST(YAMLIO, TestReadMySecondsSequence) {
684   SecondsSequence seq;
685   Input yin("---\n - hours:  1\n   seconds:  5\n - seconds:  59\n...\n");
686   yin >> seq;
688   EXPECT_FALSE(yin.error());
689   EXPECT_EQ(seq.size(), 2UL);
690   EXPECT_EQ(seq[0], 3605U);
691   EXPECT_EQ(seq[1], 59U);
695 //
696 // Test writing then reading back custom values
697 //
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);
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;
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   }
724 //===----------------------------------------------------------------------===//
725 //  Test dynamic typing
726 //===----------------------------------------------------------------------===//
728 enum AFlags {
729     a1,
730     a2,
731     a3
732 };
734 enum BFlags {
735     b1,
736     b2,
737     b3
738 };
740 enum Kind {
741     kindA,
742     kindB
743 };
745 struct KindAndFlags {
746   KindAndFlags() : kind(kindA), flags(0) { }
747   KindAndFlags(Kind k, uint32_t f) : kind(k), flags(f) { }
748   Kind        kind;
749   uint32_t    flags;
750 };
752 typedef std::vector<KindAndFlags> KindAndFlagsSequence;
754 LLVM_YAML_IS_SEQUENCE_VECTOR(KindAndFlags)
756 namespace llvm {
757 namespace yaml {
758   template <>
759   struct ScalarEnumerationTraits<AFlags> {
760     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> {
768     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> {
776     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> {
783     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   };
802 //
803 // Test the reading of a yaml sequence dynamic types
804 //
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;
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);
818 //
819 // Test writing then reading back dynamic types
820 //
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));
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;
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   }
856 //===----------------------------------------------------------------------===//
857 //  Test document list
858 //===----------------------------------------------------------------------===//
860 struct FooBarMap {
861   int foo;
862   int bar;
863 };
864 typedef std::vector<FooBarMap> FooBarMapDocumentList;
866 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(FooBarMap)
869 namespace llvm {
870 namespace yaml {
871   template <>
872   struct MappingTraits<FooBarMap> {
873     static void mapping(IO &io, FooBarMap& fb) {
874       io.mapRequired("foo",    fb.foo);
875       io.mapRequired("bar",    fb.bar);
876     }
877   };
882 //
883 // Test the reading of a yaml mapping
884 //
885 TEST(YAMLIO, TestDocRead) {
886   FooBarMap doc;
887   Input yin("---\nfoo:  3\nbar:  5\n...\n");
888   yin >> doc;
890   EXPECT_FALSE(yin.error());
891   EXPECT_EQ(doc.foo, 3);
892   EXPECT_EQ(doc.bar,5);
897 //
898 // Test writing then reading back a sequence of mappings
899 //
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);
913     llvm::raw_string_ostream ostr(intermediate);
914     Output yout(ostr);
915     yout << docList;
916   }
919   {
920     Input yin(intermediate);
921     std::vector<FooBarMap> docList2;
922     yin >> docList2;
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   }
936 //===----------------------------------------------------------------------===//
937 //  Test error handling
938 //===----------------------------------------------------------------------===//
942 static void suppressErrorMessages(const llvm::SMDiagnostic &, void *) {
946 //
947 // Test error handling of unknown enumerated scalar
948 //
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());
962 //
963 // Test error handling of flow sequence with unknown value
964 //
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;
975   EXPECT_TRUE(yin.error());
979 //
980 // Test error handling reading built-in uint8_t type
981 //
982 LLVM_YAML_IS_SEQUENCE_VECTOR(uint8_t)
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;
993   EXPECT_TRUE(yin.error());
997 //
998 // Test error handling reading built-in uint16_t type
999 //
1000 LLVM_YAML_IS_SEQUENCE_VECTOR(uint16_t)
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;
1011   EXPECT_TRUE(yin.error());
1015 //
1016 // Test error handling reading built-in uint32_t type
1017 //
1018 LLVM_YAML_IS_SEQUENCE_VECTOR(uint32_t)
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;
1029   EXPECT_TRUE(yin.error());
1033 //
1034 // Test error handling reading built-in uint64_t type
1035 //
1036 LLVM_YAML_IS_SEQUENCE_VECTOR(uint64_t)
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;
1047   EXPECT_TRUE(yin.error());
1051 //
1052 // Test error handling reading built-in int8_t type
1053 //
1054 LLVM_YAML_IS_SEQUENCE_VECTOR(int8_t)
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;
1066   EXPECT_TRUE(yin.error());
1069 //
1070 // Test error handling reading built-in int8_t type
1071 //
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;
1083   EXPECT_TRUE(yin.error());
1087 //
1088 // Test error handling reading built-in int16_t type
1089 //
1090 LLVM_YAML_IS_SEQUENCE_VECTOR(int16_t)
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;
1102   EXPECT_TRUE(yin.error());
1106 //
1107 // Test error handling reading built-in int16_t type
1108 //
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;
1120   EXPECT_TRUE(yin.error());
1124 //
1125 // Test error handling reading built-in int32_t type
1126 //
1127 LLVM_YAML_IS_SEQUENCE_VECTOR(int32_t)
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;
1139   EXPECT_TRUE(yin.error());
1142 //
1143 // Test error handling reading built-in int32_t type
1144 //
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;
1156   EXPECT_TRUE(yin.error());
1160 //
1161 // Test error handling reading built-in int64_t type
1162 //
1163 LLVM_YAML_IS_SEQUENCE_VECTOR(int64_t)
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;
1175   EXPECT_TRUE(yin.error());
1178 //
1179 // Test error handling reading built-in int64_t type
1180 //
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;
1192   EXPECT_TRUE(yin.error());
1195 //
1196 // Test error handling reading built-in float type
1197 //
1198 LLVM_YAML_IS_SEQUENCE_VECTOR(float)
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;
1210   EXPECT_TRUE(yin.error());
1213 //
1214 // Test error handling reading built-in float type
1215 //
1216 LLVM_YAML_IS_SEQUENCE_VECTOR(double)
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;
1228   EXPECT_TRUE(yin.error());
1231 //
1232 // Test error handling reading built-in Hex8 type
1233 //
1234 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex8)
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;
1245   EXPECT_TRUE(yin.error());
1249 //
1250 // Test error handling reading built-in Hex16 type
1251 //
1252 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex16)
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;
1263   EXPECT_TRUE(yin.error());
1266 //
1267 // Test error handling reading built-in Hex32 type
1268 //
1269 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex32)
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;
1280   EXPECT_TRUE(yin.error());
1283 //
1284 // Test error handling reading built-in Hex64 type
1285 //
1286 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex64)
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;
1297   EXPECT_TRUE(yin.error());