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