0f1951f4fcb3af3103473aa25b14e80e0a827156
[oota-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 //===----------------------------------------------------------------------===//
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
32 static void suppressErrorMessages(const llvm::SMDiagnostic &, void *) {
33 }
34
35
36
37 //===----------------------------------------------------------------------===//
38 //  Test MappingTraits
39 //===----------------------------------------------------------------------===//
40
41 struct FooBar {
42   int foo;
43   int bar;
44 };
45 typedef std::vector<FooBar> FooBarSequence;
46
47 LLVM_YAML_IS_SEQUENCE_VECTOR(FooBar)
48
49
50 namespace llvm {
51 namespace yaml {
52   template <>
53   struct MappingTraits<FooBar> {
54     static void mapping(IO &io, FooBar& fb) {
55       io.mapRequired("foo",    fb.foo);
56       io.mapRequired("bar",    fb.bar);
57     }
58   };
59 }
60 }
61
62
63 //
64 // Test the reading of a yaml mapping
65 //
66 TEST(YAMLIO, TestMapRead) {
67   FooBar doc;
68   {
69     Input yin("---\nfoo:  3\nbar:  5\n...\n");
70     yin >> doc;
71
72     EXPECT_FALSE(yin.error());
73     EXPECT_EQ(doc.foo, 3);
74     EXPECT_EQ(doc.bar, 5);
75   }
76
77   {
78     Input yin("{foo: 3, bar: 5}");
79     yin >> doc;
80
81     EXPECT_FALSE(yin.error());
82     EXPECT_EQ(doc.foo, 3);
83     EXPECT_EQ(doc.bar, 5);
84   }
85 }
86
87 //
88 // Test the reading of a yaml sequence of mappings
89 //
90 TEST(YAMLIO, TestSequenceMapRead) {
91   FooBarSequence seq;
92   Input yin("---\n - foo:  3\n   bar:  5\n - foo:  7\n   bar:  9\n...\n");
93   yin >> seq;
94
95   EXPECT_FALSE(yin.error());
96   EXPECT_EQ(seq.size(), 2UL);
97   FooBar& map1 = seq[0];
98   FooBar& map2 = seq[1];
99   EXPECT_EQ(map1.foo, 3);
100   EXPECT_EQ(map1.bar, 5);
101   EXPECT_EQ(map2.foo, 7);
102   EXPECT_EQ(map2.bar, 9);
103 }
104
105
106 //
107 // Test writing then reading back a sequence of mappings
108 //
109 TEST(YAMLIO, TestSequenceMapWriteAndRead) {
110   std::string intermediate;
111   {
112     FooBar entry1;
113     entry1.foo = 10;
114     entry1.bar = -3;
115     FooBar entry2;
116     entry2.foo = 257;
117     entry2.bar = 0;
118     FooBarSequence seq;
119     seq.push_back(entry1);
120     seq.push_back(entry2);
121
122     llvm::raw_string_ostream ostr(intermediate);
123     Output yout(ostr);
124     yout << seq;
125   }
126
127   {
128     Input yin(intermediate);
129     FooBarSequence seq2;
130     yin >> seq2;
131
132     EXPECT_FALSE(yin.error());
133     EXPECT_EQ(seq2.size(), 2UL);
134     FooBar& map1 = seq2[0];
135     FooBar& map2 = seq2[1];
136     EXPECT_EQ(map1.foo, 10);
137     EXPECT_EQ(map1.bar, -3);
138     EXPECT_EQ(map2.foo, 257);
139     EXPECT_EQ(map2.bar, 0);
140   }
141 }
142
143
144 //===----------------------------------------------------------------------===//
145 //  Test built-in types
146 //===----------------------------------------------------------------------===//
147
148 struct BuiltInTypes {
149   llvm::StringRef str;
150   std::string stdstr;
151   uint64_t        u64;
152   uint32_t        u32;
153   uint16_t        u16;
154   uint8_t         u8;
155   bool            b;
156   int64_t         s64;
157   int32_t         s32;
158   int16_t         s16;
159   int8_t          s8;
160   float           f;
161   double          d;
162   Hex8            h8;
163   Hex16           h16;
164   Hex32           h32;
165   Hex64           h64;
166 };
167
168 namespace llvm {
169 namespace yaml {
170   template <>
171   struct MappingTraits<BuiltInTypes> {
172     static void mapping(IO &io, BuiltInTypes& bt) {
173       io.mapRequired("str",      bt.str);
174       io.mapRequired("stdstr",   bt.stdstr);
175       io.mapRequired("u64",      bt.u64);
176       io.mapRequired("u32",      bt.u32);
177       io.mapRequired("u16",      bt.u16);
178       io.mapRequired("u8",       bt.u8);
179       io.mapRequired("b",        bt.b);
180       io.mapRequired("s64",      bt.s64);
181       io.mapRequired("s32",      bt.s32);
182       io.mapRequired("s16",      bt.s16);
183       io.mapRequired("s8",       bt.s8);
184       io.mapRequired("f",        bt.f);
185       io.mapRequired("d",        bt.d);
186       io.mapRequired("h8",       bt.h8);
187       io.mapRequired("h16",      bt.h16);
188       io.mapRequired("h32",      bt.h32);
189       io.mapRequired("h64",      bt.h64);
190     }
191   };
192 }
193 }
194
195
196 //
197 // Test the reading of all built-in scalar conversions
198 //
199 TEST(YAMLIO, TestReadBuiltInTypes) {
200   BuiltInTypes map;
201   Input yin("---\n"
202             "str:      hello there\n"
203             "stdstr:   hello where?\n"
204             "u64:      5000000000\n"
205             "u32:      4000000000\n"
206             "u16:      65000\n"
207             "u8:       255\n"
208             "b:        false\n"
209             "s64:      -5000000000\n"
210             "s32:      -2000000000\n"
211             "s16:      -32000\n"
212             "s8:       -127\n"
213             "f:        137.125\n"
214             "d:        -2.8625\n"
215             "h8:       0xFF\n"
216             "h16:      0x8765\n"
217             "h32:      0xFEDCBA98\n"
218             "h64:      0xFEDCBA9876543210\n"
219            "...\n");
220   yin >> map;
221
222   EXPECT_FALSE(yin.error());
223   EXPECT_TRUE(map.str.equals("hello there"));
224   EXPECT_TRUE(map.stdstr == "hello where?");
225   EXPECT_EQ(map.u64, 5000000000ULL);
226   EXPECT_EQ(map.u32, 4000000000U);
227   EXPECT_EQ(map.u16, 65000);
228   EXPECT_EQ(map.u8,  255);
229   EXPECT_EQ(map.b,   false);
230   EXPECT_EQ(map.s64, -5000000000LL);
231   EXPECT_EQ(map.s32, -2000000000L);
232   EXPECT_EQ(map.s16, -32000);
233   EXPECT_EQ(map.s8,  -127);
234   EXPECT_EQ(map.f,   137.125);
235   EXPECT_EQ(map.d,   -2.8625);
236   EXPECT_EQ(map.h8,  Hex8(255));
237   EXPECT_EQ(map.h16, Hex16(0x8765));
238   EXPECT_EQ(map.h32, Hex32(0xFEDCBA98));
239   EXPECT_EQ(map.h64, Hex64(0xFEDCBA9876543210LL));
240 }
241
242
243 //
244 // Test writing then reading back all built-in scalar types
245 //
246 TEST(YAMLIO, TestReadWriteBuiltInTypes) {
247   std::string intermediate;
248   {
249     BuiltInTypes map;
250     map.str = "one two";
251     map.stdstr = "three four";
252     map.u64 = 6000000000ULL;
253     map.u32 = 3000000000U;
254     map.u16 = 50000;
255     map.u8  = 254;
256     map.b   = true;
257     map.s64 = -6000000000LL;
258     map.s32 = -2000000000;
259     map.s16 = -32000;
260     map.s8  = -128;
261     map.f   = 3.25;
262     map.d   = -2.8625;
263     map.h8  = 254;
264     map.h16 = 50000;
265     map.h32 = 3000000000U;
266     map.h64 = 6000000000LL;
267
268     llvm::raw_string_ostream ostr(intermediate);
269     Output yout(ostr);
270     yout << map;
271   }
272
273   {
274     Input yin(intermediate);
275     BuiltInTypes map;
276     yin >> map;
277
278     EXPECT_FALSE(yin.error());
279     EXPECT_TRUE(map.str.equals("one two"));
280     EXPECT_TRUE(map.stdstr == "three four");
281     EXPECT_EQ(map.u64,      6000000000ULL);
282     EXPECT_EQ(map.u32,      3000000000U);
283     EXPECT_EQ(map.u16,      50000);
284     EXPECT_EQ(map.u8,       254);
285     EXPECT_EQ(map.b,        true);
286     EXPECT_EQ(map.s64,      -6000000000LL);
287     EXPECT_EQ(map.s32,      -2000000000L);
288     EXPECT_EQ(map.s16,      -32000);
289     EXPECT_EQ(map.s8,       -128);
290     EXPECT_EQ(map.f,        3.25);
291     EXPECT_EQ(map.d,        -2.8625);
292     EXPECT_EQ(map.h8,       Hex8(254));
293     EXPECT_EQ(map.h16,      Hex16(50000));
294     EXPECT_EQ(map.h32,      Hex32(3000000000U));
295     EXPECT_EQ(map.h64,      Hex64(6000000000LL));
296   }
297 }
298
299 struct StringTypes {
300   llvm::StringRef str1;
301   llvm::StringRef str2;
302   llvm::StringRef str3;
303   llvm::StringRef str4;
304   llvm::StringRef str5;
305   llvm::StringRef str6;
306   std::string stdstr1;
307   std::string stdstr2;
308   std::string stdstr3;
309   std::string stdstr4;
310   std::string stdstr5;
311   std::string stdstr6;
312 };
313
314 namespace llvm {
315 namespace yaml {
316   template <>
317   struct MappingTraits<StringTypes> {
318     static void mapping(IO &io, StringTypes& st) {
319       io.mapRequired("str1",      st.str1);
320       io.mapRequired("str2",      st.str2);
321       io.mapRequired("str3",      st.str3);
322       io.mapRequired("str4",      st.str4);
323       io.mapRequired("str5",      st.str5);
324       io.mapRequired("str6",      st.str6);
325       io.mapRequired("stdstr1",   st.stdstr1);
326       io.mapRequired("stdstr2",   st.stdstr2);
327       io.mapRequired("stdstr3",   st.stdstr3);
328       io.mapRequired("stdstr4",   st.stdstr4);
329       io.mapRequired("stdstr5",   st.stdstr5);
330       io.mapRequired("stdstr6",   st.stdstr6);
331     }
332   };
333 }
334 }
335
336 TEST(YAMLIO, TestReadWriteStringTypes) {
337   std::string intermediate;
338   {
339     StringTypes map;
340     map.str1 = "'aaa";
341     map.str2 = "\"bbb";
342     map.str3 = "`ccc";
343     map.str4 = "@ddd";
344     map.str5 = "";
345     map.str6 = "0000000004000000";
346     map.stdstr1 = "'eee";
347     map.stdstr2 = "\"fff";
348     map.stdstr3 = "`ggg";
349     map.stdstr4 = "@hhh";
350     map.stdstr5 = "";
351     map.stdstr6 = "0000000004000000";
352
353     llvm::raw_string_ostream ostr(intermediate);
354     Output yout(ostr);
355     yout << map;
356   }
357
358   llvm::StringRef flowOut(intermediate);
359   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'''aaa"));
360   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'\"bbb'"));
361   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'`ccc'"));
362   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'@ddd'"));
363   EXPECT_NE(llvm::StringRef::npos, flowOut.find("''\n"));
364   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'0000000004000000'\n"));
365   EXPECT_NE(std::string::npos, flowOut.find("'''eee"));
366   EXPECT_NE(std::string::npos, flowOut.find("'\"fff'"));
367   EXPECT_NE(std::string::npos, flowOut.find("'`ggg'"));
368   EXPECT_NE(std::string::npos, flowOut.find("'@hhh'"));
369   EXPECT_NE(std::string::npos, flowOut.find("''\n"));
370   EXPECT_NE(std::string::npos, flowOut.find("'0000000004000000'\n"));
371
372   {
373     Input yin(intermediate);
374     StringTypes map;
375     yin >> map;
376
377     EXPECT_FALSE(yin.error());
378     EXPECT_TRUE(map.str1.equals("'aaa"));
379     EXPECT_TRUE(map.str2.equals("\"bbb"));
380     EXPECT_TRUE(map.str3.equals("`ccc"));
381     EXPECT_TRUE(map.str4.equals("@ddd"));
382     EXPECT_TRUE(map.str5.equals(""));
383     EXPECT_TRUE(map.str6.equals("0000000004000000"));
384     EXPECT_TRUE(map.stdstr1 == "'eee");
385     EXPECT_TRUE(map.stdstr2 == "\"fff");
386     EXPECT_TRUE(map.stdstr3 == "`ggg");
387     EXPECT_TRUE(map.stdstr4 == "@hhh");
388     EXPECT_TRUE(map.stdstr5 == "");
389     EXPECT_TRUE(map.stdstr6 == "0000000004000000");
390   }
391 }
392
393 //===----------------------------------------------------------------------===//
394 //  Test ScalarEnumerationTraits
395 //===----------------------------------------------------------------------===//
396
397 enum Colors {
398     cRed,
399     cBlue,
400     cGreen,
401     cYellow
402 };
403
404 struct ColorMap {
405   Colors      c1;
406   Colors      c2;
407   Colors      c3;
408   Colors      c4;
409   Colors      c5;
410   Colors      c6;
411 };
412
413 namespace llvm {
414 namespace yaml {
415   template <>
416   struct ScalarEnumerationTraits<Colors> {
417     static void enumeration(IO &io, Colors &value) {
418       io.enumCase(value, "red",   cRed);
419       io.enumCase(value, "blue",  cBlue);
420       io.enumCase(value, "green", cGreen);
421       io.enumCase(value, "yellow",cYellow);
422     }
423   };
424   template <>
425   struct MappingTraits<ColorMap> {
426     static void mapping(IO &io, ColorMap& c) {
427       io.mapRequired("c1", c.c1);
428       io.mapRequired("c2", c.c2);
429       io.mapRequired("c3", c.c3);
430       io.mapOptional("c4", c.c4, cBlue);   // supplies default
431       io.mapOptional("c5", c.c5, cYellow); // supplies default
432       io.mapOptional("c6", c.c6, cRed);    // supplies default
433     }
434   };
435 }
436 }
437
438
439 //
440 // Test reading enumerated scalars
441 //
442 TEST(YAMLIO, TestEnumRead) {
443   ColorMap map;
444   Input yin("---\n"
445             "c1:  blue\n"
446             "c2:  red\n"
447             "c3:  green\n"
448             "c5:  yellow\n"
449             "...\n");
450   yin >> map;
451
452   EXPECT_FALSE(yin.error());
453   EXPECT_EQ(cBlue,  map.c1);
454   EXPECT_EQ(cRed,   map.c2);
455   EXPECT_EQ(cGreen, map.c3);
456   EXPECT_EQ(cBlue,  map.c4);  // tests default
457   EXPECT_EQ(cYellow,map.c5);  // tests overridden
458   EXPECT_EQ(cRed,   map.c6);  // tests default
459 }
460
461
462
463 //===----------------------------------------------------------------------===//
464 //  Test ScalarBitSetTraits
465 //===----------------------------------------------------------------------===//
466
467 enum MyFlags {
468   flagNone    = 0,
469   flagBig     = 1 << 0,
470   flagFlat    = 1 << 1,
471   flagRound   = 1 << 2,
472   flagPointy  = 1 << 3
473 };
474 inline MyFlags operator|(MyFlags a, MyFlags b) {
475   return static_cast<MyFlags>(
476                       static_cast<uint32_t>(a) | static_cast<uint32_t>(b));
477 }
478
479 struct FlagsMap {
480   MyFlags     f1;
481   MyFlags     f2;
482   MyFlags     f3;
483   MyFlags     f4;
484 };
485
486
487 namespace llvm {
488 namespace yaml {
489   template <>
490   struct ScalarBitSetTraits<MyFlags> {
491     static void bitset(IO &io, MyFlags &value) {
492       io.bitSetCase(value, "big",   flagBig);
493       io.bitSetCase(value, "flat",  flagFlat);
494       io.bitSetCase(value, "round", flagRound);
495       io.bitSetCase(value, "pointy",flagPointy);
496     }
497   };
498   template <>
499   struct MappingTraits<FlagsMap> {
500     static void mapping(IO &io, FlagsMap& c) {
501       io.mapRequired("f1", c.f1);
502       io.mapRequired("f2", c.f2);
503       io.mapRequired("f3", c.f3);
504       io.mapOptional("f4", c.f4, MyFlags(flagRound));
505      }
506   };
507 }
508 }
509
510
511 //
512 // Test reading flow sequence representing bit-mask values
513 //
514 TEST(YAMLIO, TestFlagsRead) {
515   FlagsMap map;
516   Input yin("---\n"
517             "f1:  [ big ]\n"
518             "f2:  [ round, flat ]\n"
519             "f3:  []\n"
520             "...\n");
521   yin >> map;
522
523   EXPECT_FALSE(yin.error());
524   EXPECT_EQ(flagBig,              map.f1);
525   EXPECT_EQ(flagRound|flagFlat,   map.f2);
526   EXPECT_EQ(flagNone,             map.f3);  // check empty set
527   EXPECT_EQ(flagRound,            map.f4);  // check optional key
528 }
529
530
531 //
532 // Test writing then reading back bit-mask values
533 //
534 TEST(YAMLIO, TestReadWriteFlags) {
535   std::string intermediate;
536   {
537     FlagsMap map;
538     map.f1 = flagBig;
539     map.f2 = flagRound | flagFlat;
540     map.f3 = flagNone;
541     map.f4 = flagNone;
542
543     llvm::raw_string_ostream ostr(intermediate);
544     Output yout(ostr);
545     yout << map;
546   }
547
548   {
549     Input yin(intermediate);
550     FlagsMap map2;
551     yin >> map2;
552
553     EXPECT_FALSE(yin.error());
554     EXPECT_EQ(flagBig,              map2.f1);
555     EXPECT_EQ(flagRound|flagFlat,   map2.f2);
556     EXPECT_EQ(flagNone,             map2.f3);
557     //EXPECT_EQ(flagRound,            map2.f4);  // check optional key
558   }
559 }
560
561
562
563 //===----------------------------------------------------------------------===//
564 //  Test ScalarTraits
565 //===----------------------------------------------------------------------===//
566
567 struct MyCustomType {
568   int length;
569   int width;
570 };
571
572 struct MyCustomTypeMap {
573   MyCustomType     f1;
574   MyCustomType     f2;
575   int              f3;
576 };
577
578
579 namespace llvm {
580 namespace yaml {
581   template <>
582   struct MappingTraits<MyCustomTypeMap> {
583     static void mapping(IO &io, MyCustomTypeMap& s) {
584       io.mapRequired("f1", s.f1);
585       io.mapRequired("f2", s.f2);
586       io.mapRequired("f3", s.f3);
587      }
588   };
589   // MyCustomType is formatted as a yaml scalar.  A value of
590   // {length=3, width=4} would be represented in yaml as "3 by 4".
591   template<>
592   struct ScalarTraits<MyCustomType> {
593     static void output(const MyCustomType &value, void* ctxt, llvm::raw_ostream &out) {
594       out << llvm::format("%d by %d", value.length, value.width);
595     }
596     static StringRef input(StringRef scalar, void* ctxt, MyCustomType &value) {
597       size_t byStart = scalar.find("by");
598       if ( byStart != StringRef::npos ) {
599         StringRef lenStr = scalar.slice(0, byStart);
600         lenStr = lenStr.rtrim();
601         if ( lenStr.getAsInteger(0, value.length) ) {
602           return "malformed length";
603         }
604         StringRef widthStr = scalar.drop_front(byStart+2);
605         widthStr = widthStr.ltrim();
606         if ( widthStr.getAsInteger(0, value.width) ) {
607           return "malformed width";
608         }
609         return StringRef();
610       }
611       else {
612           return "malformed by";
613       }
614     }
615   };
616 }
617 }
618
619
620 //
621 // Test writing then reading back custom values
622 //
623 TEST(YAMLIO, TestReadWriteMyCustomType) {
624   std::string intermediate;
625   {
626     MyCustomTypeMap map;
627     map.f1.length = 1;
628     map.f1.width  = 4;
629     map.f2.length = 100;
630     map.f2.width  = 400;
631     map.f3 = 10;
632
633     llvm::raw_string_ostream ostr(intermediate);
634     Output yout(ostr);
635     yout << map;
636   }
637
638   {
639     Input yin(intermediate);
640     MyCustomTypeMap map2;
641     yin >> map2;
642
643     EXPECT_FALSE(yin.error());
644     EXPECT_EQ(1,      map2.f1.length);
645     EXPECT_EQ(4,      map2.f1.width);
646     EXPECT_EQ(100,    map2.f2.length);
647     EXPECT_EQ(400,    map2.f2.width);
648     EXPECT_EQ(10,     map2.f3);
649   }
650 }
651
652
653 //===----------------------------------------------------------------------===//
654 //  Test flow sequences
655 //===----------------------------------------------------------------------===//
656
657 LLVM_YAML_STRONG_TYPEDEF(int, MyNumber)
658 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(MyNumber)
659 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::StringRef)
660
661 namespace llvm {
662 namespace yaml {
663   template<>
664   struct ScalarTraits<MyNumber> {
665     static void output(const MyNumber &value, void *, llvm::raw_ostream &out) {
666       out << value;
667     }
668
669     static StringRef input(StringRef scalar, void *, MyNumber &value) {
670       long long n;
671       if ( getAsSignedInteger(scalar, 0, n) )
672         return "invalid number";
673       value = n;
674       return StringRef();
675     }
676   };
677 }
678 }
679
680 struct NameAndNumbers {
681   llvm::StringRef               name;
682   std::vector<llvm::StringRef>  strings;
683   std::vector<MyNumber>         single;
684   std::vector<MyNumber>         numbers;
685 };
686
687 namespace llvm {
688 namespace yaml {
689   template <>
690   struct MappingTraits<NameAndNumbers> {
691     static void mapping(IO &io, NameAndNumbers& nn) {
692       io.mapRequired("name",     nn.name);
693       io.mapRequired("strings",  nn.strings);
694       io.mapRequired("single",   nn.single);
695       io.mapRequired("numbers",  nn.numbers);
696     }
697   };
698 }
699 }
700
701
702 //
703 // Test writing then reading back custom values
704 //
705 TEST(YAMLIO, TestReadWriteMyFlowSequence) {
706   std::string intermediate;
707   {
708     NameAndNumbers map;
709     map.name  = "hello";
710     map.strings.push_back(llvm::StringRef("one"));
711     map.strings.push_back(llvm::StringRef("two"));
712     map.single.push_back(1);
713     map.numbers.push_back(10);
714     map.numbers.push_back(-30);
715     map.numbers.push_back(1024);
716
717     llvm::raw_string_ostream ostr(intermediate);
718     Output yout(ostr);
719     yout << map;
720
721     // Verify sequences were written in flow style
722     ostr.flush();
723     llvm::StringRef flowOut(intermediate);
724     EXPECT_NE(llvm::StringRef::npos, flowOut.find("one, two"));
725     EXPECT_NE(llvm::StringRef::npos, flowOut.find("10, -30, 1024"));
726   }
727
728   {
729     Input yin(intermediate);
730     NameAndNumbers map2;
731     yin >> map2;
732
733     EXPECT_FALSE(yin.error());
734     EXPECT_TRUE(map2.name.equals("hello"));
735     EXPECT_EQ(map2.strings.size(), 2UL);
736     EXPECT_TRUE(map2.strings[0].equals("one"));
737     EXPECT_TRUE(map2.strings[1].equals("two"));
738     EXPECT_EQ(map2.single.size(), 1UL);
739     EXPECT_EQ(1,       map2.single[0]);
740     EXPECT_EQ(map2.numbers.size(), 3UL);
741     EXPECT_EQ(10,      map2.numbers[0]);
742     EXPECT_EQ(-30,     map2.numbers[1]);
743     EXPECT_EQ(1024,    map2.numbers[2]);
744   }
745 }
746
747
748 //===----------------------------------------------------------------------===//
749 //  Test normalizing/denormalizing
750 //===----------------------------------------------------------------------===//
751
752 LLVM_YAML_STRONG_TYPEDEF(uint32_t, TotalSeconds)
753
754 typedef std::vector<TotalSeconds> SecondsSequence;
755
756 LLVM_YAML_IS_SEQUENCE_VECTOR(TotalSeconds)
757
758
759 namespace llvm {
760 namespace yaml {
761   template <>
762   struct MappingTraits<TotalSeconds> {
763
764     class NormalizedSeconds {
765     public:
766       NormalizedSeconds(IO &io)
767         : hours(0), minutes(0), seconds(0) {
768       }
769       NormalizedSeconds(IO &, TotalSeconds &secs)
770         : hours(secs/3600),
771           minutes((secs - (hours*3600))/60),
772           seconds(secs % 60) {
773       }
774       TotalSeconds denormalize(IO &) {
775         return TotalSeconds(hours*3600 + minutes*60 + seconds);
776       }
777
778       uint32_t     hours;
779       uint8_t      minutes;
780       uint8_t      seconds;
781     };
782
783     static void mapping(IO &io, TotalSeconds &secs) {
784       MappingNormalization<NormalizedSeconds, TotalSeconds> keys(io, secs);
785
786       io.mapOptional("hours",    keys->hours,    (uint32_t)0);
787       io.mapOptional("minutes",  keys->minutes,  (uint8_t)0);
788       io.mapRequired("seconds",  keys->seconds);
789     }
790   };
791 }
792 }
793
794
795 //
796 // Test the reading of a yaml sequence of mappings
797 //
798 TEST(YAMLIO, TestReadMySecondsSequence) {
799   SecondsSequence seq;
800   Input yin("---\n - hours:  1\n   seconds:  5\n - seconds:  59\n...\n");
801   yin >> seq;
802
803   EXPECT_FALSE(yin.error());
804   EXPECT_EQ(seq.size(), 2UL);
805   EXPECT_EQ(seq[0], 3605U);
806   EXPECT_EQ(seq[1], 59U);
807 }
808
809
810 //
811 // Test writing then reading back custom values
812 //
813 TEST(YAMLIO, TestReadWriteMySecondsSequence) {
814   std::string intermediate;
815   {
816     SecondsSequence seq;
817     seq.push_back(4000);
818     seq.push_back(500);
819     seq.push_back(59);
820
821     llvm::raw_string_ostream ostr(intermediate);
822     Output yout(ostr);
823     yout << seq;
824   }
825   {
826     Input yin(intermediate);
827     SecondsSequence seq2;
828     yin >> seq2;
829
830     EXPECT_FALSE(yin.error());
831     EXPECT_EQ(seq2.size(), 3UL);
832     EXPECT_EQ(seq2[0], 4000U);
833     EXPECT_EQ(seq2[1], 500U);
834     EXPECT_EQ(seq2[2], 59U);
835   }
836 }
837
838
839 //===----------------------------------------------------------------------===//
840 //  Test dynamic typing
841 //===----------------------------------------------------------------------===//
842
843 enum AFlags {
844     a1,
845     a2,
846     a3
847 };
848
849 enum BFlags {
850     b1,
851     b2,
852     b3
853 };
854
855 enum Kind {
856     kindA,
857     kindB
858 };
859
860 struct KindAndFlags {
861   KindAndFlags() : kind(kindA), flags(0) { }
862   KindAndFlags(Kind k, uint32_t f) : kind(k), flags(f) { }
863   Kind        kind;
864   uint32_t    flags;
865 };
866
867 typedef std::vector<KindAndFlags> KindAndFlagsSequence;
868
869 LLVM_YAML_IS_SEQUENCE_VECTOR(KindAndFlags)
870
871 namespace llvm {
872 namespace yaml {
873   template <>
874   struct ScalarEnumerationTraits<AFlags> {
875     static void enumeration(IO &io, AFlags &value) {
876       io.enumCase(value, "a1",  a1);
877       io.enumCase(value, "a2",  a2);
878       io.enumCase(value, "a3",  a3);
879     }
880   };
881   template <>
882   struct ScalarEnumerationTraits<BFlags> {
883     static void enumeration(IO &io, BFlags &value) {
884       io.enumCase(value, "b1",  b1);
885       io.enumCase(value, "b2",  b2);
886       io.enumCase(value, "b3",  b3);
887     }
888   };
889   template <>
890   struct ScalarEnumerationTraits<Kind> {
891     static void enumeration(IO &io, Kind &value) {
892       io.enumCase(value, "A",  kindA);
893       io.enumCase(value, "B",  kindB);
894     }
895   };
896   template <>
897   struct MappingTraits<KindAndFlags> {
898     static void mapping(IO &io, KindAndFlags& kf) {
899       io.mapRequired("kind",  kf.kind);
900       // Type of "flags" field varies depending on "kind" field.
901       // Use memcpy here to avoid breaking strict aliasing rules.
902       if (kf.kind == kindA) {
903         AFlags aflags = static_cast<AFlags>(kf.flags);
904         io.mapRequired("flags", aflags);
905         kf.flags = aflags;
906       } else {
907         BFlags bflags = static_cast<BFlags>(kf.flags);
908         io.mapRequired("flags", bflags);
909         kf.flags = bflags;
910       }
911     }
912   };
913 }
914 }
915
916
917 //
918 // Test the reading of a yaml sequence dynamic types
919 //
920 TEST(YAMLIO, TestReadKindAndFlagsSequence) {
921   KindAndFlagsSequence seq;
922   Input yin("---\n - kind:  A\n   flags:  a2\n - kind:  B\n   flags:  b1\n...\n");
923   yin >> seq;
924
925   EXPECT_FALSE(yin.error());
926   EXPECT_EQ(seq.size(), 2UL);
927   EXPECT_EQ(seq[0].kind,  kindA);
928   EXPECT_EQ(seq[0].flags, (uint32_t)a2);
929   EXPECT_EQ(seq[1].kind,  kindB);
930   EXPECT_EQ(seq[1].flags, (uint32_t)b1);
931 }
932
933 //
934 // Test writing then reading back dynamic types
935 //
936 TEST(YAMLIO, TestReadWriteKindAndFlagsSequence) {
937   std::string intermediate;
938   {
939     KindAndFlagsSequence seq;
940     seq.push_back(KindAndFlags(kindA,a1));
941     seq.push_back(KindAndFlags(kindB,b1));
942     seq.push_back(KindAndFlags(kindA,a2));
943     seq.push_back(KindAndFlags(kindB,b2));
944     seq.push_back(KindAndFlags(kindA,a3));
945
946     llvm::raw_string_ostream ostr(intermediate);
947     Output yout(ostr);
948     yout << seq;
949   }
950   {
951     Input yin(intermediate);
952     KindAndFlagsSequence seq2;
953     yin >> seq2;
954
955     EXPECT_FALSE(yin.error());
956     EXPECT_EQ(seq2.size(), 5UL);
957     EXPECT_EQ(seq2[0].kind,  kindA);
958     EXPECT_EQ(seq2[0].flags, (uint32_t)a1);
959     EXPECT_EQ(seq2[1].kind,  kindB);
960     EXPECT_EQ(seq2[1].flags, (uint32_t)b1);
961     EXPECT_EQ(seq2[2].kind,  kindA);
962     EXPECT_EQ(seq2[2].flags, (uint32_t)a2);
963     EXPECT_EQ(seq2[3].kind,  kindB);
964     EXPECT_EQ(seq2[3].flags, (uint32_t)b2);
965     EXPECT_EQ(seq2[4].kind,  kindA);
966     EXPECT_EQ(seq2[4].flags, (uint32_t)a3);
967   }
968 }
969
970
971 //===----------------------------------------------------------------------===//
972 //  Test document list
973 //===----------------------------------------------------------------------===//
974
975 struct FooBarMap {
976   int foo;
977   int bar;
978 };
979 typedef std::vector<FooBarMap> FooBarMapDocumentList;
980
981 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(FooBarMap)
982
983
984 namespace llvm {
985 namespace yaml {
986   template <>
987   struct MappingTraits<FooBarMap> {
988     static void mapping(IO &io, FooBarMap& fb) {
989       io.mapRequired("foo",    fb.foo);
990       io.mapRequired("bar",    fb.bar);
991     }
992   };
993 }
994 }
995
996
997 //
998 // Test the reading of a yaml mapping
999 //
1000 TEST(YAMLIO, TestDocRead) {
1001   FooBarMap doc;
1002   Input yin("---\nfoo:  3\nbar:  5\n...\n");
1003   yin >> doc;
1004
1005   EXPECT_FALSE(yin.error());
1006   EXPECT_EQ(doc.foo, 3);
1007   EXPECT_EQ(doc.bar,5);
1008 }
1009
1010
1011
1012 //
1013 // Test writing then reading back a sequence of mappings
1014 //
1015 TEST(YAMLIO, TestSequenceDocListWriteAndRead) {
1016   std::string intermediate;
1017   {
1018     FooBarMap doc1;
1019     doc1.foo = 10;
1020     doc1.bar = -3;
1021     FooBarMap doc2;
1022     doc2.foo = 257;
1023     doc2.bar = 0;
1024     std::vector<FooBarMap> docList;
1025     docList.push_back(doc1);
1026     docList.push_back(doc2);
1027
1028     llvm::raw_string_ostream ostr(intermediate);
1029     Output yout(ostr);
1030     yout << docList;
1031   }
1032
1033
1034   {
1035     Input yin(intermediate);
1036     std::vector<FooBarMap> docList2;
1037     yin >> docList2;
1038
1039     EXPECT_FALSE(yin.error());
1040     EXPECT_EQ(docList2.size(), 2UL);
1041     FooBarMap& map1 = docList2[0];
1042     FooBarMap& map2 = docList2[1];
1043     EXPECT_EQ(map1.foo, 10);
1044     EXPECT_EQ(map1.bar, -3);
1045     EXPECT_EQ(map2.foo, 257);
1046     EXPECT_EQ(map2.bar, 0);
1047   }
1048 }
1049
1050 //===----------------------------------------------------------------------===//
1051 //  Test document tags
1052 //===----------------------------------------------------------------------===//
1053
1054 struct MyDouble {
1055   MyDouble() : value(0.0) { }
1056   MyDouble(double x) : value(x) { }
1057   double value;
1058 };
1059
1060 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(MyDouble)
1061
1062
1063 namespace llvm {
1064 namespace yaml {
1065   template <>
1066   struct MappingTraits<MyDouble> {
1067     static void mapping(IO &io, MyDouble &d) {
1068       if (io.mapTag("!decimal", true)) {
1069         mappingDecimal(io, d);
1070       } else if (io.mapTag("!fraction")) {
1071         mappingFraction(io, d);
1072       }
1073     }
1074     static void mappingDecimal(IO &io, MyDouble &d) {
1075       io.mapRequired("value", d.value);
1076     }
1077     static void mappingFraction(IO &io, MyDouble &d) {
1078         double num, denom;
1079         io.mapRequired("numerator",      num);
1080         io.mapRequired("denominator",    denom);
1081         // convert fraction to double
1082         d.value = num/denom;
1083     }
1084   };
1085  }
1086 }
1087
1088
1089 //
1090 // Test the reading of two different tagged yaml documents.
1091 //
1092 TEST(YAMLIO, TestTaggedDocuments) {
1093   std::vector<MyDouble> docList;
1094   Input yin("--- !decimal\nvalue:  3.0\n"
1095             "--- !fraction\nnumerator:  9.0\ndenominator:  2\n...\n");
1096   yin >> docList;
1097   EXPECT_FALSE(yin.error());
1098   EXPECT_EQ(docList.size(), 2UL);
1099   EXPECT_EQ(docList[0].value, 3.0);
1100   EXPECT_EQ(docList[1].value, 4.5);
1101 }
1102
1103
1104
1105 //
1106 // Test writing then reading back tagged documents
1107 //
1108 TEST(YAMLIO, TestTaggedDocumentsWriteAndRead) {
1109   std::string intermediate;
1110   {
1111     MyDouble a(10.25);
1112     MyDouble b(-3.75);
1113     std::vector<MyDouble> docList;
1114     docList.push_back(a);
1115     docList.push_back(b);
1116
1117     llvm::raw_string_ostream ostr(intermediate);
1118     Output yout(ostr);
1119     yout << docList;
1120   }
1121
1122   {
1123     Input yin(intermediate);
1124     std::vector<MyDouble> docList2;
1125     yin >> docList2;
1126
1127     EXPECT_FALSE(yin.error());
1128     EXPECT_EQ(docList2.size(), 2UL);
1129     EXPECT_EQ(docList2[0].value, 10.25);
1130     EXPECT_EQ(docList2[1].value, -3.75);
1131   }
1132 }
1133
1134
1135 //===----------------------------------------------------------------------===//
1136 //  Test mapping validation
1137 //===----------------------------------------------------------------------===//
1138
1139 struct MyValidation {
1140   double value;
1141 };
1142
1143 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(MyValidation)
1144
1145 namespace llvm {
1146 namespace yaml {
1147   template <>
1148   struct MappingTraits<MyValidation> {
1149     static void mapping(IO &io, MyValidation &d) {
1150         io.mapRequired("value", d.value);
1151     }
1152     static StringRef validate(IO &io, MyValidation &d) {
1153         if (d.value < 0)
1154           return "negative value";
1155         return StringRef();
1156     }
1157   };
1158  }
1159 }
1160
1161
1162 //
1163 // Test that validate() is called and complains about the negative value.
1164 //
1165 TEST(YAMLIO, TestValidatingInput) {
1166   std::vector<MyValidation> docList;
1167   Input yin("--- \nvalue:  3.0\n"
1168             "--- \nvalue:  -1.0\n...\n",
1169             NULL, suppressErrorMessages);
1170   yin >> docList;
1171   EXPECT_TRUE(yin.error());
1172 }
1173
1174
1175 //===----------------------------------------------------------------------===//
1176 //  Test error handling
1177 //===----------------------------------------------------------------------===//
1178
1179 //
1180 // Test error handling of unknown enumerated scalar
1181 //
1182 TEST(YAMLIO, TestColorsReadError) {
1183   ColorMap map;
1184   Input yin("---\n"
1185             "c1:  blue\n"
1186             "c2:  purple\n"
1187             "c3:  green\n"
1188             "...\n",
1189             /*Ctxt=*/NULL,
1190             suppressErrorMessages);
1191   yin >> map;
1192   EXPECT_TRUE(yin.error());
1193 }
1194
1195
1196 //
1197 // Test error handling of flow sequence with unknown value
1198 //
1199 TEST(YAMLIO, TestFlagsReadError) {
1200   FlagsMap map;
1201   Input yin("---\n"
1202             "f1:  [ big ]\n"
1203             "f2:  [ round, hollow ]\n"
1204             "f3:  []\n"
1205             "...\n",
1206             /*Ctxt=*/NULL,
1207             suppressErrorMessages);
1208   yin >> map;
1209
1210   EXPECT_TRUE(yin.error());
1211 }
1212
1213
1214 //
1215 // Test error handling reading built-in uint8_t type
1216 //
1217 LLVM_YAML_IS_SEQUENCE_VECTOR(uint8_t)
1218 TEST(YAMLIO, TestReadBuiltInTypesUint8Error) {
1219   std::vector<uint8_t> seq;
1220   Input yin("---\n"
1221             "- 255\n"
1222             "- 0\n"
1223             "- 257\n"
1224             "...\n",
1225             /*Ctxt=*/NULL,
1226             suppressErrorMessages);
1227   yin >> seq;
1228
1229   EXPECT_TRUE(yin.error());
1230 }
1231
1232
1233 //
1234 // Test error handling reading built-in uint16_t type
1235 //
1236 LLVM_YAML_IS_SEQUENCE_VECTOR(uint16_t)
1237 TEST(YAMLIO, TestReadBuiltInTypesUint16Error) {
1238   std::vector<uint16_t> seq;
1239   Input yin("---\n"
1240             "- 65535\n"
1241             "- 0\n"
1242             "- 66000\n"
1243             "...\n",
1244             /*Ctxt=*/NULL,
1245             suppressErrorMessages);
1246   yin >> seq;
1247
1248   EXPECT_TRUE(yin.error());
1249 }
1250
1251
1252 //
1253 // Test error handling reading built-in uint32_t type
1254 //
1255 LLVM_YAML_IS_SEQUENCE_VECTOR(uint32_t)
1256 TEST(YAMLIO, TestReadBuiltInTypesUint32Error) {
1257   std::vector<uint32_t> seq;
1258   Input yin("---\n"
1259             "- 4000000000\n"
1260             "- 0\n"
1261             "- 5000000000\n"
1262             "...\n",
1263             /*Ctxt=*/NULL,
1264             suppressErrorMessages);
1265   yin >> seq;
1266
1267   EXPECT_TRUE(yin.error());
1268 }
1269
1270
1271 //
1272 // Test error handling reading built-in uint64_t type
1273 //
1274 LLVM_YAML_IS_SEQUENCE_VECTOR(uint64_t)
1275 TEST(YAMLIO, TestReadBuiltInTypesUint64Error) {
1276   std::vector<uint64_t> seq;
1277   Input yin("---\n"
1278             "- 18446744073709551615\n"
1279             "- 0\n"
1280             "- 19446744073709551615\n"
1281             "...\n",
1282             /*Ctxt=*/NULL,
1283             suppressErrorMessages);
1284   yin >> seq;
1285
1286   EXPECT_TRUE(yin.error());
1287 }
1288
1289
1290 //
1291 // Test error handling reading built-in int8_t type
1292 //
1293 LLVM_YAML_IS_SEQUENCE_VECTOR(int8_t)
1294 TEST(YAMLIO, TestReadBuiltInTypesint8OverError) {
1295   std::vector<int8_t> seq;
1296   Input yin("---\n"
1297             "- -128\n"
1298             "- 0\n"
1299             "- 127\n"
1300             "- 128\n"
1301            "...\n",
1302             /*Ctxt=*/NULL,
1303             suppressErrorMessages);
1304   yin >> seq;
1305
1306   EXPECT_TRUE(yin.error());
1307 }
1308
1309 //
1310 // Test error handling reading built-in int8_t type
1311 //
1312 TEST(YAMLIO, TestReadBuiltInTypesint8UnderError) {
1313   std::vector<int8_t> seq;
1314   Input yin("---\n"
1315             "- -128\n"
1316             "- 0\n"
1317             "- 127\n"
1318             "- -129\n"
1319             "...\n",
1320             /*Ctxt=*/NULL,
1321             suppressErrorMessages);
1322   yin >> seq;
1323
1324   EXPECT_TRUE(yin.error());
1325 }
1326
1327
1328 //
1329 // Test error handling reading built-in int16_t type
1330 //
1331 LLVM_YAML_IS_SEQUENCE_VECTOR(int16_t)
1332 TEST(YAMLIO, TestReadBuiltInTypesint16UnderError) {
1333   std::vector<int16_t> seq;
1334   Input yin("---\n"
1335             "- 32767\n"
1336             "- 0\n"
1337             "- -32768\n"
1338             "- -32769\n"
1339             "...\n",
1340             /*Ctxt=*/NULL,
1341             suppressErrorMessages);
1342   yin >> seq;
1343
1344   EXPECT_TRUE(yin.error());
1345 }
1346
1347
1348 //
1349 // Test error handling reading built-in int16_t type
1350 //
1351 TEST(YAMLIO, TestReadBuiltInTypesint16OverError) {
1352   std::vector<int16_t> seq;
1353   Input yin("---\n"
1354             "- 32767\n"
1355             "- 0\n"
1356             "- -32768\n"
1357             "- 32768\n"
1358             "...\n",
1359             /*Ctxt=*/NULL,
1360             suppressErrorMessages);
1361   yin >> seq;
1362
1363   EXPECT_TRUE(yin.error());
1364 }
1365
1366
1367 //
1368 // Test error handling reading built-in int32_t type
1369 //
1370 LLVM_YAML_IS_SEQUENCE_VECTOR(int32_t)
1371 TEST(YAMLIO, TestReadBuiltInTypesint32UnderError) {
1372   std::vector<int32_t> seq;
1373   Input yin("---\n"
1374             "- 2147483647\n"
1375             "- 0\n"
1376             "- -2147483648\n"
1377             "- -2147483649\n"
1378             "...\n",
1379             /*Ctxt=*/NULL,
1380             suppressErrorMessages);
1381   yin >> seq;
1382
1383   EXPECT_TRUE(yin.error());
1384 }
1385
1386 //
1387 // Test error handling reading built-in int32_t type
1388 //
1389 TEST(YAMLIO, TestReadBuiltInTypesint32OverError) {
1390   std::vector<int32_t> seq;
1391   Input yin("---\n"
1392             "- 2147483647\n"
1393             "- 0\n"
1394             "- -2147483648\n"
1395             "- 2147483649\n"
1396             "...\n",
1397             /*Ctxt=*/NULL,
1398             suppressErrorMessages);
1399   yin >> seq;
1400
1401   EXPECT_TRUE(yin.error());
1402 }
1403
1404
1405 //
1406 // Test error handling reading built-in int64_t type
1407 //
1408 LLVM_YAML_IS_SEQUENCE_VECTOR(int64_t)
1409 TEST(YAMLIO, TestReadBuiltInTypesint64UnderError) {
1410   std::vector<int64_t> seq;
1411   Input yin("---\n"
1412             "- -9223372036854775808\n"
1413             "- 0\n"
1414             "- 9223372036854775807\n"
1415             "- -9223372036854775809\n"
1416             "...\n",
1417             /*Ctxt=*/NULL,
1418             suppressErrorMessages);
1419   yin >> seq;
1420
1421   EXPECT_TRUE(yin.error());
1422 }
1423
1424 //
1425 // Test error handling reading built-in int64_t type
1426 //
1427 TEST(YAMLIO, TestReadBuiltInTypesint64OverError) {
1428   std::vector<int64_t> seq;
1429   Input yin("---\n"
1430             "- -9223372036854775808\n"
1431             "- 0\n"
1432             "- 9223372036854775807\n"
1433             "- 9223372036854775809\n"
1434             "...\n",
1435             /*Ctxt=*/NULL,
1436             suppressErrorMessages);
1437   yin >> seq;
1438
1439   EXPECT_TRUE(yin.error());
1440 }
1441
1442 //
1443 // Test error handling reading built-in float type
1444 //
1445 LLVM_YAML_IS_SEQUENCE_VECTOR(float)
1446 TEST(YAMLIO, TestReadBuiltInTypesFloatError) {
1447   std::vector<float> seq;
1448   Input yin("---\n"
1449             "- 0.0\n"
1450             "- 1000.1\n"
1451             "- -123.456\n"
1452             "- 1.2.3\n"
1453             "...\n",
1454             /*Ctxt=*/NULL,
1455             suppressErrorMessages);
1456   yin >> seq;
1457
1458   EXPECT_TRUE(yin.error());
1459 }
1460
1461 //
1462 // Test error handling reading built-in float type
1463 //
1464 LLVM_YAML_IS_SEQUENCE_VECTOR(double)
1465 TEST(YAMLIO, TestReadBuiltInTypesDoubleError) {
1466   std::vector<double> seq;
1467   Input yin("---\n"
1468             "- 0.0\n"
1469             "- 1000.1\n"
1470             "- -123.456\n"
1471             "- 1.2.3\n"
1472             "...\n",
1473             /*Ctxt=*/NULL,
1474             suppressErrorMessages);
1475   yin >> seq;
1476
1477   EXPECT_TRUE(yin.error());
1478 }
1479
1480 //
1481 // Test error handling reading built-in Hex8 type
1482 //
1483 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex8)
1484 TEST(YAMLIO, TestReadBuiltInTypesHex8Error) {
1485   std::vector<Hex8> seq;
1486   Input yin("---\n"
1487             "- 0x12\n"
1488             "- 0xFE\n"
1489             "- 0x123\n"
1490             "...\n",
1491             /*Ctxt=*/NULL,
1492             suppressErrorMessages);
1493   yin >> seq;
1494
1495   EXPECT_TRUE(yin.error());
1496 }
1497
1498
1499 //
1500 // Test error handling reading built-in Hex16 type
1501 //
1502 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex16)
1503 TEST(YAMLIO, TestReadBuiltInTypesHex16Error) {
1504   std::vector<Hex16> seq;
1505   Input yin("---\n"
1506             "- 0x0012\n"
1507             "- 0xFEFF\n"
1508             "- 0x12345\n"
1509             "...\n",
1510             /*Ctxt=*/NULL,
1511             suppressErrorMessages);
1512   yin >> seq;
1513
1514   EXPECT_TRUE(yin.error());
1515 }
1516
1517 //
1518 // Test error handling reading built-in Hex32 type
1519 //
1520 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex32)
1521 TEST(YAMLIO, TestReadBuiltInTypesHex32Error) {
1522   std::vector<Hex32> seq;
1523   Input yin("---\n"
1524             "- 0x0012\n"
1525             "- 0xFEFF0000\n"
1526             "- 0x1234556789\n"
1527             "...\n",
1528             /*Ctxt=*/NULL,
1529             suppressErrorMessages);
1530   yin >> seq;
1531
1532   EXPECT_TRUE(yin.error());
1533 }
1534
1535 //
1536 // Test error handling reading built-in Hex64 type
1537 //
1538 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex64)
1539 TEST(YAMLIO, TestReadBuiltInTypesHex64Error) {
1540   std::vector<Hex64> seq;
1541   Input yin("---\n"
1542             "- 0x0012\n"
1543             "- 0xFFEEDDCCBBAA9988\n"
1544             "- 0x12345567890ABCDEF0\n"
1545             "...\n",
1546             /*Ctxt=*/NULL,
1547             suppressErrorMessages);
1548   yin >> seq;
1549
1550   EXPECT_TRUE(yin.error());
1551 }
1552
1553 TEST(YAMLIO, TestMalformedMapFailsGracefully) {
1554   FooBar doc;
1555   {
1556     // We pass the suppressErrorMessages handler to handle the error
1557     // message generated in the constructor of Input.
1558     Input yin("{foo:3, bar: 5}", /*Ctxt=*/NULL, suppressErrorMessages);
1559     yin >> doc;
1560     EXPECT_TRUE(yin.error());
1561   }
1562
1563   {
1564     Input yin("---\nfoo:3\nbar: 5\n...\n", /*Ctxt=*/NULL, suppressErrorMessages);
1565     yin >> doc;
1566     EXPECT_TRUE(yin.error());
1567   }
1568 }
1569
1570 struct OptionalTest {
1571   std::vector<int> Numbers;
1572 };
1573
1574 struct OptionalTestSeq {
1575   std::vector<OptionalTest> Tests;
1576 };
1577
1578 LLVM_YAML_IS_SEQUENCE_VECTOR(OptionalTest)
1579 namespace llvm {
1580 namespace yaml {
1581   template <>
1582   struct MappingTraits<OptionalTest> {
1583     static void mapping(IO& IO, OptionalTest &OT) {
1584       IO.mapOptional("Numbers", OT.Numbers);
1585     }
1586   };
1587
1588   template <>
1589   struct MappingTraits<OptionalTestSeq> {
1590     static void mapping(IO &IO, OptionalTestSeq &OTS) {
1591       IO.mapOptional("Tests", OTS.Tests);
1592     }
1593   };
1594 }
1595 }
1596
1597 TEST(YAMLIO, SequenceElideTest) {
1598   // Test that writing out a purely optional structure with its fields set to
1599   // default followed by other data is properly read back in.
1600   OptionalTestSeq Seq;
1601   OptionalTest One, Two, Three, Four;
1602   int N[] = {1, 2, 3};
1603   Three.Numbers.assign(N, N + 3);
1604   Seq.Tests.push_back(One);
1605   Seq.Tests.push_back(Two);
1606   Seq.Tests.push_back(Three);
1607   Seq.Tests.push_back(Four);
1608
1609   std::string intermediate;
1610   {
1611     llvm::raw_string_ostream ostr(intermediate);
1612     Output yout(ostr);
1613     yout << Seq;
1614   }
1615
1616   Input yin(intermediate);
1617   OptionalTestSeq Seq2;
1618   yin >> Seq2;
1619
1620   EXPECT_FALSE(yin.error());
1621
1622   EXPECT_EQ(4UL, Seq2.Tests.size());
1623
1624   EXPECT_TRUE(Seq2.Tests[0].Numbers.empty());
1625   EXPECT_TRUE(Seq2.Tests[1].Numbers.empty());
1626
1627   EXPECT_EQ(1, Seq2.Tests[2].Numbers[0]);
1628   EXPECT_EQ(2, Seq2.Tests[2].Numbers[1]);
1629   EXPECT_EQ(3, Seq2.Tests[2].Numbers[2]);
1630
1631   EXPECT_TRUE(Seq2.Tests[3].Numbers.empty());
1632 }
1633
1634 TEST(YAMLIO, TestEmptyStringFailsForMapWithRequiredFields) {
1635   FooBar doc;
1636   Input yin("");
1637   yin >> doc;
1638   EXPECT_TRUE(yin.error());
1639 }
1640
1641 TEST(YAMLIO, TestEmptyStringSucceedsForMapWithOptionalFields) {
1642   OptionalTest doc;
1643   Input yin("");
1644   yin >> doc;
1645   EXPECT_FALSE(yin.error());
1646 }
1647
1648 TEST(YAMLIO, TestEmptyStringSucceedsForSequence) {
1649   std::vector<uint8_t> seq;
1650   Input yin("", /*Ctxt=*/NULL, suppressErrorMessages);
1651   yin >> seq;
1652
1653   EXPECT_FALSE(yin.error());
1654   EXPECT_TRUE(seq.empty());
1655 }