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 struct FooBarContainer {
  50   FooBarSequence fbs;
  51 };
  52
  53 namespace llvm {
  54 namespace yaml {
  55   template <>
  56   struct MappingTraits<FooBar> {
  57     static void mapping(IO &io, FooBar& fb) {
  58       io.mapRequired("foo",    fb.foo);
  59       io.mapRequired("bar",    fb.bar);
  60     }
  61   };
  62
  63   template <> struct MappingTraits<FooBarContainer> {
  64     static void mapping(IO &io, FooBarContainer &fb) {
  65       io.mapRequired("fbs", fb.fbs);
  66     }
  67   };
  68 }
  69 }
  70
  71
  72 //
  73 // Test the reading of a yaml mapping
  74 //
  75 TEST(YAMLIO, TestMapRead) {
  76   FooBar doc;
  77   {
  78     Input yin("---\nfoo:  3\nbar:  5\n...\n");
  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     Input yin("{foo: 3, bar: 5}");
  88     yin >> doc;
  89
  90     EXPECT_FALSE(yin.error());
  91     EXPECT_EQ(doc.foo, 3);
  92     EXPECT_EQ(doc.bar, 5);
  93   }
  94 }
  95
  96 TEST(YAMLIO, TestMalformedMapRead) {
  97   FooBar doc;
  98   Input yin("{foo: 3; bar: 5}", nullptr, suppressErrorMessages);
  99   yin >> doc;
 100   EXPECT_TRUE(!!yin.error());
 101 }
 102
 103 //
 104 // Test the reading of a yaml sequence of mappings
 105 //
 106 TEST(YAMLIO, TestSequenceMapRead) {
 107   FooBarSequence seq;
 108   Input yin("---\n - foo:  3\n   bar:  5\n - foo:  7\n   bar:  9\n...\n");
 109   yin >> seq;
 110
 111   EXPECT_FALSE(yin.error());
 112   EXPECT_EQ(seq.size(), 2UL);
 113   FooBar& map1 = seq[0];
 114   FooBar& map2 = seq[1];
 115   EXPECT_EQ(map1.foo, 3);
 116   EXPECT_EQ(map1.bar, 5);
 117   EXPECT_EQ(map2.foo, 7);
 118   EXPECT_EQ(map2.bar, 9);
 119 }
 120
 121 //
 122 // Test the reading of a map containing a yaml sequence of mappings
 123 //
 124 TEST(YAMLIO, TestContainerSequenceMapRead) {
 125   {
 126     FooBarContainer cont;
 127     Input yin2("---\nfbs:\n - foo: 3\n   bar: 5\n - foo: 7\n   bar: 9\n...\n");
 128     yin2 >> cont;
 129
 130     EXPECT_FALSE(yin2.error());
 131     EXPECT_EQ(cont.fbs.size(), 2UL);
 132     EXPECT_EQ(cont.fbs[0].foo, 3);
 133     EXPECT_EQ(cont.fbs[0].bar, 5);
 134     EXPECT_EQ(cont.fbs[1].foo, 7);
 135     EXPECT_EQ(cont.fbs[1].bar, 9);
 136   }
 137
 138   {
 139     FooBarContainer cont;
 140     Input yin("---\nfbs:\n...\n");
 141     yin >> cont;
 142     // Okay: Empty node represents an empty array.
 143     EXPECT_FALSE(yin.error());
 144     EXPECT_EQ(cont.fbs.size(), 0UL);
 145   }
 146
 147   {
 148     FooBarContainer cont;
 149     Input yin("---\nfbs: !!null null\n...\n");
 150     yin >> cont;
 151     // Okay: null represents an empty array.
 152     EXPECT_FALSE(yin.error());
 153     EXPECT_EQ(cont.fbs.size(), 0UL);
 154   }
 155
 156   {
 157     FooBarContainer cont;
 158     Input yin("---\nfbs: ~\n...\n");
 159     yin >> cont;
 160     // Okay: null represents an empty array.
 161     EXPECT_FALSE(yin.error());
 162     EXPECT_EQ(cont.fbs.size(), 0UL);
 163   }
 164
 165   {
 166     FooBarContainer cont;
 167     Input yin("---\nfbs: null\n...\n");
 168     yin >> cont;
 169     // Okay: null represents an empty array.
 170     EXPECT_FALSE(yin.error());
 171     EXPECT_EQ(cont.fbs.size(), 0UL);
 172   }
 173 }
 174
 175 //
 176 // Test the reading of a map containing a malformed yaml sequence
 177 //
 178 TEST(YAMLIO, TestMalformedContainerSequenceMapRead) {
 179   {
 180     FooBarContainer cont;
 181     Input yin("---\nfbs:\n   foo: 3\n   bar: 5\n...\n", nullptr,
 182               suppressErrorMessages);
 183     yin >> cont;
 184     // Error: fbs is not a sequence.
 185     EXPECT_TRUE(!!yin.error());
 186     EXPECT_EQ(cont.fbs.size(), 0UL);
 187   }
 188
 189   {
 190     FooBarContainer cont;
 191     Input yin("---\nfbs: 'scalar'\n...\n", nullptr, suppressErrorMessages);
 192     yin >> cont;
 193     // This should be an error.
 194     EXPECT_TRUE(!!yin.error());
 195     EXPECT_EQ(cont.fbs.size(), 0UL);
 196   }
 197 }
 198
 199 //
 200 // Test writing then reading back a sequence of mappings
 201 //
 202 TEST(YAMLIO, TestSequenceMapWriteAndRead) {
 203   std::string intermediate;
 204   {
 205     FooBar entry1;
 206     entry1.foo = 10;
 207     entry1.bar = -3;
 208     FooBar entry2;
 209     entry2.foo = 257;
 210     entry2.bar = 0;
 211     FooBarSequence seq;
 212     seq.push_back(entry1);
 213     seq.push_back(entry2);
 214
 215     llvm::raw_string_ostream ostr(intermediate);
 216     Output yout(ostr);
 217     yout << seq;
 218   }
 219
 220   {
 221     Input yin(intermediate);
 222     FooBarSequence seq2;
 223     yin >> seq2;
 224
 225     EXPECT_FALSE(yin.error());
 226     EXPECT_EQ(seq2.size(), 2UL);
 227     FooBar& map1 = seq2[0];
 228     FooBar& map2 = seq2[1];
 229     EXPECT_EQ(map1.foo, 10);
 230     EXPECT_EQ(map1.bar, -3);
 231     EXPECT_EQ(map2.foo, 257);
 232     EXPECT_EQ(map2.bar, 0);
 233   }
 234 }
 235
 236
 237 //===----------------------------------------------------------------------===//
 238 //  Test built-in types
 239 //===----------------------------------------------------------------------===//
 240
 241 struct BuiltInTypes {
 242   llvm::StringRef str;
 243   std::string stdstr;
 244   uint64_t        u64;
 245   uint32_t        u32;
 246   uint16_t        u16;
 247   uint8_t         u8;
 248   bool            b;
 249   int64_t         s64;
 250   int32_t         s32;
 251   int16_t         s16;
 252   int8_t          s8;
 253   float           f;
 254   double          d;
 255   Hex8            h8;
 256   Hex16           h16;
 257   Hex32           h32;
 258   Hex64           h64;
 259 };
 260
 261 namespace llvm {
 262 namespace yaml {
 263   template <>
 264   struct MappingTraits<BuiltInTypes> {
 265     static void mapping(IO &io, BuiltInTypes& bt) {
 266       io.mapRequired("str",      bt.str);
 267       io.mapRequired("stdstr",   bt.stdstr);
 268       io.mapRequired("u64",      bt.u64);
 269       io.mapRequired("u32",      bt.u32);
 270       io.mapRequired("u16",      bt.u16);
 271       io.mapRequired("u8",       bt.u8);
 272       io.mapRequired("b",        bt.b);
 273       io.mapRequired("s64",      bt.s64);
 274       io.mapRequired("s32",      bt.s32);
 275       io.mapRequired("s16",      bt.s16);
 276       io.mapRequired("s8",       bt.s8);
 277       io.mapRequired("f",        bt.f);
 278       io.mapRequired("d",        bt.d);
 279       io.mapRequired("h8",       bt.h8);
 280       io.mapRequired("h16",      bt.h16);
 281       io.mapRequired("h32",      bt.h32);
 282       io.mapRequired("h64",      bt.h64);
 283     }
 284   };
 285 }
 286 }
 287
 288
 289 //
 290 // Test the reading of all built-in scalar conversions
 291 //
 292 TEST(YAMLIO, TestReadBuiltInTypes) {
 293   BuiltInTypes map;
 294   Input yin("---\n"
 295             "str:      hello there\n"
 296             "stdstr:   hello where?\n"
 297             "u64:      5000000000\n"
 298             "u32:      4000000000\n"
 299             "u16:      65000\n"
 300             "u8:       255\n"
 301             "b:        false\n"
 302             "s64:      -5000000000\n"
 303             "s32:      -2000000000\n"
 304             "s16:      -32000\n"
 305             "s8:       -127\n"
 306             "f:        137.125\n"
 307             "d:        -2.8625\n"
 308             "h8:       0xFF\n"
 309             "h16:      0x8765\n"
 310             "h32:      0xFEDCBA98\n"
 311             "h64:      0xFEDCBA9876543210\n"
 312            "...\n");
 313   yin >> map;
 314
 315   EXPECT_FALSE(yin.error());
 316   EXPECT_TRUE(map.str.equals("hello there"));
 317   EXPECT_TRUE(map.stdstr == "hello where?");
 318   EXPECT_EQ(map.u64, 5000000000ULL);
 319   EXPECT_EQ(map.u32, 4000000000U);
 320   EXPECT_EQ(map.u16, 65000);
 321   EXPECT_EQ(map.u8,  255);
 322   EXPECT_EQ(map.b,   false);
 323   EXPECT_EQ(map.s64, -5000000000LL);
 324   EXPECT_EQ(map.s32, -2000000000L);
 325   EXPECT_EQ(map.s16, -32000);
 326   EXPECT_EQ(map.s8,  -127);
 327   EXPECT_EQ(map.f,   137.125);
 328   EXPECT_EQ(map.d,   -2.8625);
 329   EXPECT_EQ(map.h8,  Hex8(255));
 330   EXPECT_EQ(map.h16, Hex16(0x8765));
 331   EXPECT_EQ(map.h32, Hex32(0xFEDCBA98));
 332   EXPECT_EQ(map.h64, Hex64(0xFEDCBA9876543210LL));
 333 }
 334
 335
 336 //
 337 // Test writing then reading back all built-in scalar types
 338 //
 339 TEST(YAMLIO, TestReadWriteBuiltInTypes) {
 340   std::string intermediate;
 341   {
 342     BuiltInTypes map;
 343     map.str = "one two";
 344     map.stdstr = "three four";
 345     map.u64 = 6000000000ULL;
 346     map.u32 = 3000000000U;
 347     map.u16 = 50000;
 348     map.u8  = 254;
 349     map.b   = true;
 350     map.s64 = -6000000000LL;
 351     map.s32 = -2000000000;
 352     map.s16 = -32000;
 353     map.s8  = -128;
 354     map.f   = 3.25;
 355     map.d   = -2.8625;
 356     map.h8  = 254;
 357     map.h16 = 50000;
 358     map.h32 = 3000000000U;
 359     map.h64 = 6000000000LL;
 360
 361     llvm::raw_string_ostream ostr(intermediate);
 362     Output yout(ostr);
 363     yout << map;
 364   }
 365
 366   {
 367     Input yin(intermediate);
 368     BuiltInTypes map;
 369     yin >> map;
 370
 371     EXPECT_FALSE(yin.error());
 372     EXPECT_TRUE(map.str.equals("one two"));
 373     EXPECT_TRUE(map.stdstr == "three four");
 374     EXPECT_EQ(map.u64,      6000000000ULL);
 375     EXPECT_EQ(map.u32,      3000000000U);
 376     EXPECT_EQ(map.u16,      50000);
 377     EXPECT_EQ(map.u8,       254);
 378     EXPECT_EQ(map.b,        true);
 379     EXPECT_EQ(map.s64,      -6000000000LL);
 380     EXPECT_EQ(map.s32,      -2000000000L);
 381     EXPECT_EQ(map.s16,      -32000);
 382     EXPECT_EQ(map.s8,       -128);
 383     EXPECT_EQ(map.f,        3.25);
 384     EXPECT_EQ(map.d,        -2.8625);
 385     EXPECT_EQ(map.h8,       Hex8(254));
 386     EXPECT_EQ(map.h16,      Hex16(50000));
 387     EXPECT_EQ(map.h32,      Hex32(3000000000U));
 388     EXPECT_EQ(map.h64,      Hex64(6000000000LL));
 389   }
 390 }
 391
 392 struct StringTypes {
 393   llvm::StringRef str1;
 394   llvm::StringRef str2;
 395   llvm::StringRef str3;
 396   llvm::StringRef str4;
 397   llvm::StringRef str5;
 398   llvm::StringRef str6;
 399   llvm::StringRef str7;
 400   llvm::StringRef str8;
 401   llvm::StringRef str9;
 402   llvm::StringRef str10;
 403   llvm::StringRef str11;
 404   std::string stdstr1;
 405   std::string stdstr2;
 406   std::string stdstr3;
 407   std::string stdstr4;
 408   std::string stdstr5;
 409   std::string stdstr6;
 410   std::string stdstr7;
 411   std::string stdstr8;
 412   std::string stdstr9;
 413   std::string stdstr10;
 414   std::string stdstr11;
 415 };
 416
 417 namespace llvm {
 418 namespace yaml {
 419   template <>
 420   struct MappingTraits<StringTypes> {
 421     static void mapping(IO &io, StringTypes& st) {
 422       io.mapRequired("str1",      st.str1);
 423       io.mapRequired("str2",      st.str2);
 424       io.mapRequired("str3",      st.str3);
 425       io.mapRequired("str4",      st.str4);
 426       io.mapRequired("str5",      st.str5);
 427       io.mapRequired("str6",      st.str6);
 428       io.mapRequired("str7",      st.str7);
 429       io.mapRequired("str8",      st.str8);
 430       io.mapRequired("str9",      st.str9);
 431       io.mapRequired("str10",     st.str10);
 432       io.mapRequired("str11",     st.str11);
 433       io.mapRequired("stdstr1",   st.stdstr1);
 434       io.mapRequired("stdstr2",   st.stdstr2);
 435       io.mapRequired("stdstr3",   st.stdstr3);
 436       io.mapRequired("stdstr4",   st.stdstr4);
 437       io.mapRequired("stdstr5",   st.stdstr5);
 438       io.mapRequired("stdstr6",   st.stdstr6);
 439       io.mapRequired("stdstr7",   st.stdstr7);
 440       io.mapRequired("stdstr8",   st.stdstr8);
 441       io.mapRequired("stdstr9",   st.stdstr9);
 442       io.mapRequired("stdstr10",  st.stdstr10);
 443       io.mapRequired("stdstr11",  st.stdstr11);
 444     }
 445   };
 446 }
 447 }
 448
 449 TEST(YAMLIO, TestReadWriteStringTypes) {
 450   std::string intermediate;
 451   {
 452     StringTypes map;
 453     map.str1 = "'aaa";
 454     map.str2 = "\"bbb";
 455     map.str3 = "`ccc";
 456     map.str4 = "@ddd";
 457     map.str5 = "";
 458     map.str6 = "0000000004000000";
 459     map.str7 = "true";
 460     map.str8 = "FALSE";
 461     map.str9 = "~";
 462     map.str10 = "0.2e20";
 463     map.str11 = "0x30";
 464     map.stdstr1 = "'eee";
 465     map.stdstr2 = "\"fff";
 466     map.stdstr3 = "`ggg";
 467     map.stdstr4 = "@hhh";
 468     map.stdstr5 = "";
 469     map.stdstr6 = "0000000004000000";
 470     map.stdstr7 = "true";
 471     map.stdstr8 = "FALSE";
 472     map.stdstr9 = "~";
 473     map.stdstr10 = "0.2e20";
 474     map.stdstr11 = "0x30";
 475
 476     llvm::raw_string_ostream ostr(intermediate);
 477     Output yout(ostr);
 478     yout << map;
 479   }
 480
 481   llvm::StringRef flowOut(intermediate);
 482   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'''aaa"));
 483   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'\"bbb'"));
 484   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'`ccc'"));
 485   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'@ddd'"));
 486   EXPECT_NE(llvm::StringRef::npos, flowOut.find("''\n"));
 487   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'0000000004000000'\n"));
 488   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'true'\n"));
 489   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'FALSE'\n"));
 490   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'~'\n"));
 491   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'0.2e20'\n"));
 492   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'0x30'\n"));
 493   EXPECT_NE(std::string::npos, flowOut.find("'''eee"));
 494   EXPECT_NE(std::string::npos, flowOut.find("'\"fff'"));
 495   EXPECT_NE(std::string::npos, flowOut.find("'`ggg'"));
 496   EXPECT_NE(std::string::npos, flowOut.find("'@hhh'"));
 497   EXPECT_NE(std::string::npos, flowOut.find("''\n"));
 498   EXPECT_NE(std::string::npos, flowOut.find("'0000000004000000'\n"));
 499
 500   {
 501     Input yin(intermediate);
 502     StringTypes map;
 503     yin >> map;
 504
 505     EXPECT_FALSE(yin.error());
 506     EXPECT_TRUE(map.str1.equals("'aaa"));
 507     EXPECT_TRUE(map.str2.equals("\"bbb"));
 508     EXPECT_TRUE(map.str3.equals("`ccc"));
 509     EXPECT_TRUE(map.str4.equals("@ddd"));
 510     EXPECT_TRUE(map.str5.equals(""));
 511     EXPECT_TRUE(map.str6.equals("0000000004000000"));
 512     EXPECT_TRUE(map.stdstr1 == "'eee");
 513     EXPECT_TRUE(map.stdstr2 == "\"fff");
 514     EXPECT_TRUE(map.stdstr3 == "`ggg");
 515     EXPECT_TRUE(map.stdstr4 == "@hhh");
 516     EXPECT_TRUE(map.stdstr5 == "");
 517     EXPECT_TRUE(map.stdstr6 == "0000000004000000");
 518   }
 519 }
 520
 521 //===----------------------------------------------------------------------===//
 522 //  Test ScalarEnumerationTraits
 523 //===----------------------------------------------------------------------===//
 524
 525 enum Colors {
 526     cRed,
 527     cBlue,
 528     cGreen,
 529     cYellow
 530 };
 531
 532 struct ColorMap {
 533   Colors      c1;
 534   Colors      c2;
 535   Colors      c3;
 536   Colors      c4;
 537   Colors      c5;
 538   Colors      c6;
 539 };
 540
 541 namespace llvm {
 542 namespace yaml {
 543   template <>
 544   struct ScalarEnumerationTraits<Colors> {
 545     static void enumeration(IO &io, Colors &value) {
 546       io.enumCase(value, "red",   cRed);
 547       io.enumCase(value, "blue",  cBlue);
 548       io.enumCase(value, "green", cGreen);
 549       io.enumCase(value, "yellow",cYellow);
 550     }
 551   };
 552   template <>
 553   struct MappingTraits<ColorMap> {
 554     static void mapping(IO &io, ColorMap& c) {
 555       io.mapRequired("c1", c.c1);
 556       io.mapRequired("c2", c.c2);
 557       io.mapRequired("c3", c.c3);
 558       io.mapOptional("c4", c.c4, cBlue);   // supplies default
 559       io.mapOptional("c5", c.c5, cYellow); // supplies default
 560       io.mapOptional("c6", c.c6, cRed);    // supplies default
 561     }
 562   };
 563 }
 564 }
 565
 566
 567 //
 568 // Test reading enumerated scalars
 569 //
 570 TEST(YAMLIO, TestEnumRead) {
 571   ColorMap map;
 572   Input yin("---\n"
 573             "c1:  blue\n"
 574             "c2:  red\n"
 575             "c3:  green\n"
 576             "c5:  yellow\n"
 577             "...\n");
 578   yin >> map;
 579
 580   EXPECT_FALSE(yin.error());
 581   EXPECT_EQ(cBlue,  map.c1);
 582   EXPECT_EQ(cRed,   map.c2);
 583   EXPECT_EQ(cGreen, map.c3);
 584   EXPECT_EQ(cBlue,  map.c4);  // tests default
 585   EXPECT_EQ(cYellow,map.c5);  // tests overridden
 586   EXPECT_EQ(cRed,   map.c6);  // tests default
 587 }
 588
 589
 590
 591 //===----------------------------------------------------------------------===//
 592 //  Test ScalarBitSetTraits
 593 //===----------------------------------------------------------------------===//
 594
 595 enum MyFlags {
 596   flagNone    = 0,
 597   flagBig     = 1 << 0,
 598   flagFlat    = 1 << 1,
 599   flagRound   = 1 << 2,
 600   flagPointy  = 1 << 3
 601 };
 602 inline MyFlags operator|(MyFlags a, MyFlags b) {
 603   return static_cast<MyFlags>(
 604                       static_cast<uint32_t>(a) | static_cast<uint32_t>(b));
 605 }
 606
 607 struct FlagsMap {
 608   MyFlags     f1;
 609   MyFlags     f2;
 610   MyFlags     f3;
 611   MyFlags     f4;
 612 };
 613
 614
 615 namespace llvm {
 616 namespace yaml {
 617   template <>
 618   struct ScalarBitSetTraits<MyFlags> {
 619     static void bitset(IO &io, MyFlags &value) {
 620       io.bitSetCase(value, "big",   flagBig);
 621       io.bitSetCase(value, "flat",  flagFlat);
 622       io.bitSetCase(value, "round", flagRound);
 623       io.bitSetCase(value, "pointy",flagPointy);
 624     }
 625   };
 626   template <>
 627   struct MappingTraits<FlagsMap> {
 628     static void mapping(IO &io, FlagsMap& c) {
 629       io.mapRequired("f1", c.f1);
 630       io.mapRequired("f2", c.f2);
 631       io.mapRequired("f3", c.f3);
 632       io.mapOptional("f4", c.f4, MyFlags(flagRound));
 633      }
 634   };
 635 }
 636 }
 637
 638
 639 //
 640 // Test reading flow sequence representing bit-mask values
 641 //
 642 TEST(YAMLIO, TestFlagsRead) {
 643   FlagsMap map;
 644   Input yin("---\n"
 645             "f1:  [ big ]\n"
 646             "f2:  [ round, flat ]\n"
 647             "f3:  []\n"
 648             "...\n");
 649   yin >> map;
 650
 651   EXPECT_FALSE(yin.error());
 652   EXPECT_EQ(flagBig,              map.f1);
 653   EXPECT_EQ(flagRound|flagFlat,   map.f2);
 654   EXPECT_EQ(flagNone,             map.f3);  // check empty set
 655   EXPECT_EQ(flagRound,            map.f4);  // check optional key
 656 }
 657
 658
 659 //
 660 // Test writing then reading back bit-mask values
 661 //
 662 TEST(YAMLIO, TestReadWriteFlags) {
 663   std::string intermediate;
 664   {
 665     FlagsMap map;
 666     map.f1 = flagBig;
 667     map.f2 = flagRound | flagFlat;
 668     map.f3 = flagNone;
 669     map.f4 = flagNone;
 670
 671     llvm::raw_string_ostream ostr(intermediate);
 672     Output yout(ostr);
 673     yout << map;
 674   }
 675
 676   {
 677     Input yin(intermediate);
 678     FlagsMap map2;
 679     yin >> map2;
 680
 681     EXPECT_FALSE(yin.error());
 682     EXPECT_EQ(flagBig,              map2.f1);
 683     EXPECT_EQ(flagRound|flagFlat,   map2.f2);
 684     EXPECT_EQ(flagNone,             map2.f3);
 685     //EXPECT_EQ(flagRound,            map2.f4);  // check optional key
 686   }
 687 }
 688
 689
 690
 691 //===----------------------------------------------------------------------===//
 692 //  Test ScalarTraits
 693 //===----------------------------------------------------------------------===//
 694
 695 struct MyCustomType {
 696   int length;
 697   int width;
 698 };
 699
 700 struct MyCustomTypeMap {
 701   MyCustomType     f1;
 702   MyCustomType     f2;
 703   int              f3;
 704 };
 705
 706
 707 namespace llvm {
 708 namespace yaml {
 709   template <>
 710   struct MappingTraits<MyCustomTypeMap> {
 711     static void mapping(IO &io, MyCustomTypeMap& s) {
 712       io.mapRequired("f1", s.f1);
 713       io.mapRequired("f2", s.f2);
 714       io.mapRequired("f3", s.f3);
 715      }
 716   };
 717   // MyCustomType is formatted as a yaml scalar.  A value of
 718   // {length=3, width=4} would be represented in yaml as "3 by 4".
 719   template<>
 720   struct ScalarTraits<MyCustomType> {
 721     static void output(const MyCustomType &value, void* ctxt, llvm::raw_ostream &out) {
 722       out << llvm::format("%d by %d", value.length, value.width);
 723     }
 724     static StringRef input(StringRef scalar, void* ctxt, MyCustomType &value) {
 725       size_t byStart = scalar.find("by");
 726       if ( byStart != StringRef::npos ) {
 727         StringRef lenStr = scalar.slice(0, byStart);
 728         lenStr = lenStr.rtrim();
 729         if ( lenStr.getAsInteger(0, value.length) ) {
 730           return "malformed length";
 731         }
 732         StringRef widthStr = scalar.drop_front(byStart+2);
 733         widthStr = widthStr.ltrim();
 734         if ( widthStr.getAsInteger(0, value.width) ) {
 735           return "malformed width";
 736         }
 737         return StringRef();
 738       }
 739       else {
 740           return "malformed by";
 741       }
 742     }
 743     static bool mustQuote(StringRef) { return true; }
 744   };
 745 }
 746 }
 747
 748
 749 //
 750 // Test writing then reading back custom values
 751 //
 752 TEST(YAMLIO, TestReadWriteMyCustomType) {
 753   std::string intermediate;
 754   {
 755     MyCustomTypeMap map;
 756     map.f1.length = 1;
 757     map.f1.width  = 4;
 758     map.f2.length = 100;
 759     map.f2.width  = 400;
 760     map.f3 = 10;
 761
 762     llvm::raw_string_ostream ostr(intermediate);
 763     Output yout(ostr);
 764     yout << map;
 765   }
 766
 767   {
 768     Input yin(intermediate);
 769     MyCustomTypeMap map2;
 770     yin >> map2;
 771
 772     EXPECT_FALSE(yin.error());
 773     EXPECT_EQ(1,      map2.f1.length);
 774     EXPECT_EQ(4,      map2.f1.width);
 775     EXPECT_EQ(100,    map2.f2.length);
 776     EXPECT_EQ(400,    map2.f2.width);
 777     EXPECT_EQ(10,     map2.f3);
 778   }
 779 }
 780
 781
 782 //===----------------------------------------------------------------------===//
 783 //  Test BlockScalarTraits
 784 //===----------------------------------------------------------------------===//
 785
 786 struct MultilineStringType {
 787   std::string str;
 788 };
 789
 790 struct MultilineStringTypeMap {
 791   MultilineStringType name;
 792   MultilineStringType description;
 793   MultilineStringType ingredients;
 794   MultilineStringType recipes;
 795   MultilineStringType warningLabels;
 796   MultilineStringType documentation;
 797   int price;
 798 };
 799
 800 namespace llvm {
 801 namespace yaml {
 802   template <>
 803   struct MappingTraits<MultilineStringTypeMap> {
 804     static void mapping(IO &io, MultilineStringTypeMap& s) {
 805       io.mapRequired("name", s.name);
 806       io.mapRequired("description", s.description);
 807       io.mapRequired("ingredients", s.ingredients);
 808       io.mapRequired("recipes", s.recipes);
 809       io.mapRequired("warningLabels", s.warningLabels);
 810       io.mapRequired("documentation", s.documentation);
 811       io.mapRequired("price", s.price);
 812      }
 813   };
 814
 815   // MultilineStringType is formatted as a yaml block literal scalar. A value of
 816   // "Hello\nWorld" would be represented in yaml as
 817   //  |
 818   //    Hello
 819   //    World
 820   template <>
 821   struct BlockScalarTraits<MultilineStringType> {
 822     static void output(const MultilineStringType &value, void *ctxt,
 823                        llvm::raw_ostream &out) {
 824       out << value.str;
 825     }
 826     static StringRef input(StringRef scalar, void *ctxt,
 827                            MultilineStringType &value) {
 828       value.str = scalar.str();
 829       return StringRef();
 830     }
 831   };
 832 }
 833 }
 834
 835 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(MultilineStringType)
 836
 837 //
 838 // Test writing then reading back custom values
 839 //
 840 TEST(YAMLIO, TestReadWriteMultilineStringType) {
 841   std::string intermediate;
 842   {
 843     MultilineStringTypeMap map;
 844     map.name.str = "An Item";
 845     map.description.str = "Hello\nWorld";
 846     map.ingredients.str = "SubItem 1\nSub Item 2\n\nSub Item 3\n";
 847     map.recipes.str = "\n\nTest 1\n\n\n";
 848     map.warningLabels.str = "";
 849     map.documentation.str = "\n\n";
 850     map.price = 350;
 851
 852     llvm::raw_string_ostream ostr(intermediate);
 853     Output yout(ostr);
 854     yout << map;
 855   }
 856   {
 857     Input yin(intermediate);
 858     MultilineStringTypeMap map2;
 859     yin >> map2;
 860
 861     EXPECT_FALSE(yin.error());
 862     EXPECT_EQ(map2.name.str, "An Item\n");
 863     EXPECT_EQ(map2.description.str, "Hello\nWorld\n");
 864     EXPECT_EQ(map2.ingredients.str, "SubItem 1\nSub Item 2\n\nSub Item 3\n");
 865     EXPECT_EQ(map2.recipes.str, "\n\nTest 1\n");
 866     EXPECT_TRUE(map2.warningLabels.str.empty());
 867     EXPECT_TRUE(map2.documentation.str.empty());
 868     EXPECT_EQ(map2.price, 350);
 869   }
 870 }
 871
 872 //
 873 // Test writing then reading back custom values
 874 //
 875 TEST(YAMLIO, TestReadWriteBlockScalarDocuments) {
 876   std::string intermediate;
 877   {
 878     std::vector<MultilineStringType> documents;
 879     MultilineStringType doc;
 880     doc.str = "Hello\nWorld";
 881     documents.push_back(doc);
 882
 883     llvm::raw_string_ostream ostr(intermediate);
 884     Output yout(ostr);
 885     yout << documents;
 886
 887     // Verify that the block scalar header was written out on the same line
 888     // as the document marker.
 889     EXPECT_NE(llvm::StringRef::npos, llvm::StringRef(ostr.str()).find("--- |"));
 890   }
 891   {
 892     Input yin(intermediate);
 893     std::vector<MultilineStringType> documents2;
 894     yin >> documents2;
 895
 896     EXPECT_FALSE(yin.error());
 897     EXPECT_EQ(documents2.size(), size_t(1));
 898     EXPECT_EQ(documents2[0].str, "Hello\nWorld\n");
 899   }
 900 }
 901
 902 TEST(YAMLIO, TestReadWriteBlockScalarValue) {
 903   std::string intermediate;
 904   {
 905     MultilineStringType doc;
 906     doc.str = "Just a block\nscalar doc";
 907
 908     llvm::raw_string_ostream ostr(intermediate);
 909     Output yout(ostr);
 910     yout << doc;
 911   }
 912   {
 913     Input yin(intermediate);
 914     MultilineStringType doc;
 915     yin >> doc;
 916
 917     EXPECT_FALSE(yin.error());
 918     EXPECT_EQ(doc.str, "Just a block\nscalar doc\n");
 919   }
 920 }
 921
 922 //===----------------------------------------------------------------------===//
 923 //  Test flow sequences
 924 //===----------------------------------------------------------------------===//
 925
 926 LLVM_YAML_STRONG_TYPEDEF(int, MyNumber)
 927 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(MyNumber)
 928 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::StringRef)
 929
 930 namespace llvm {
 931 namespace yaml {
 932   template<>
 933   struct ScalarTraits<MyNumber> {
 934     static void output(const MyNumber &value, void *, llvm::raw_ostream &out) {
 935       out << value;
 936     }
 937
 938     static StringRef input(StringRef scalar, void *, MyNumber &value) {
 939       long long n;
 940       if ( getAsSignedInteger(scalar, 0, n) )
 941         return "invalid number";
 942       value = n;
 943       return StringRef();
 944     }
 945
 946     static bool mustQuote(StringRef) { return false; }
 947   };
 948 }
 949 }
 950
 951 struct NameAndNumbers {
 952   llvm::StringRef               name;
 953   std::vector<llvm::StringRef>  strings;
 954   std::vector<MyNumber>         single;
 955   std::vector<MyNumber>         numbers;
 956 };
 957
 958 namespace llvm {
 959 namespace yaml {
 960   template <>
 961   struct MappingTraits<NameAndNumbers> {
 962     static void mapping(IO &io, NameAndNumbers& nn) {
 963       io.mapRequired("name",     nn.name);
 964       io.mapRequired("strings",  nn.strings);
 965       io.mapRequired("single",   nn.single);
 966       io.mapRequired("numbers",  nn.numbers);
 967     }
 968   };
 969 }
 970 }
 971
 972 typedef std::vector<MyNumber> MyNumberFlowSequence;
 973
 974 LLVM_YAML_IS_SEQUENCE_VECTOR(MyNumberFlowSequence)
 975
 976 struct NameAndNumbersFlow {
 977   llvm::StringRef                    name;
 978   std::vector<MyNumberFlowSequence>  sequenceOfNumbers;
 979 };
 980
 981 namespace llvm {
 982 namespace yaml {
 983   template <>
 984   struct MappingTraits<NameAndNumbersFlow> {
 985     static void mapping(IO &io, NameAndNumbersFlow& nn) {
 986       io.mapRequired("name",     nn.name);
 987       io.mapRequired("sequenceOfNumbers",  nn.sequenceOfNumbers);
 988     }
 989   };
 990 }
 991 }
 992
 993 //
 994 // Test writing then reading back custom values
 995 //
 996 TEST(YAMLIO, TestReadWriteMyFlowSequence) {
 997   std::string intermediate;
 998   {
 999     NameAndNumbers map;
1000     map.name  = "hello";
1001     map.strings.push_back(llvm::StringRef("one"));
1002     map.strings.push_back(llvm::StringRef("two"));
1003     map.single.push_back(1);
1004     map.numbers.push_back(10);
1005     map.numbers.push_back(-30);
1006     map.numbers.push_back(1024);
1007
1008     llvm::raw_string_ostream ostr(intermediate);
1009     Output yout(ostr);
1010     yout << map;
1011
1012     // Verify sequences were written in flow style
1013     ostr.flush();
1014     llvm::StringRef flowOut(intermediate);
1015     EXPECT_NE(llvm::StringRef::npos, flowOut.find("one, two"));
1016     EXPECT_NE(llvm::StringRef::npos, flowOut.find("10, -30, 1024"));
1017   }
1018
1019   {
1020     Input yin(intermediate);
1021     NameAndNumbers map2;
1022     yin >> map2;
1023
1024     EXPECT_FALSE(yin.error());
1025     EXPECT_TRUE(map2.name.equals("hello"));
1026     EXPECT_EQ(map2.strings.size(), 2UL);
1027     EXPECT_TRUE(map2.strings[0].equals("one"));
1028     EXPECT_TRUE(map2.strings[1].equals("two"));
1029     EXPECT_EQ(map2.single.size(), 1UL);
1030     EXPECT_EQ(1,       map2.single[0]);
1031     EXPECT_EQ(map2.numbers.size(), 3UL);
1032     EXPECT_EQ(10,      map2.numbers[0]);
1033     EXPECT_EQ(-30,     map2.numbers[1]);
1034     EXPECT_EQ(1024,    map2.numbers[2]);
1035   }
1036 }
1037
1038
1039 //
1040 // Test writing then reading back a sequence of flow sequences.
1041 //
1042 TEST(YAMLIO, TestReadWriteSequenceOfMyFlowSequence) {
1043   std::string intermediate;
1044   {
1045     NameAndNumbersFlow map;
1046     map.name  = "hello";
1047     MyNumberFlowSequence single = { 0 };
1048     MyNumberFlowSequence numbers = { 12, 1, -512 };
1049     map.sequenceOfNumbers.push_back(single);
1050     map.sequenceOfNumbers.push_back(numbers);
1051     map.sequenceOfNumbers.push_back(MyNumberFlowSequence());
1052
1053     llvm::raw_string_ostream ostr(intermediate);
1054     Output yout(ostr);
1055     yout << map;
1056
1057     // Verify sequences were written in flow style
1058     // and that the parent sequence used '-'.
1059     ostr.flush();
1060     llvm::StringRef flowOut(intermediate);
1061     EXPECT_NE(llvm::StringRef::npos, flowOut.find("- [ 0 ]"));
1062     EXPECT_NE(llvm::StringRef::npos, flowOut.find("- [ 12, 1, -512 ]"));
1063     EXPECT_NE(llvm::StringRef::npos, flowOut.find("- [  ]"));
1064   }
1065
1066   {
1067     Input yin(intermediate);
1068     NameAndNumbersFlow map2;
1069     yin >> map2;
1070
1071     EXPECT_FALSE(yin.error());
1072     EXPECT_TRUE(map2.name.equals("hello"));
1073     EXPECT_EQ(map2.sequenceOfNumbers.size(), 3UL);
1074     EXPECT_EQ(map2.sequenceOfNumbers[0].size(), 1UL);
1075     EXPECT_EQ(0,    map2.sequenceOfNumbers[0][0]);
1076     EXPECT_EQ(map2.sequenceOfNumbers[1].size(), 3UL);
1077     EXPECT_EQ(12,   map2.sequenceOfNumbers[1][0]);
1078     EXPECT_EQ(1,    map2.sequenceOfNumbers[1][1]);
1079     EXPECT_EQ(-512, map2.sequenceOfNumbers[1][2]);
1080     EXPECT_TRUE(map2.sequenceOfNumbers[2].empty());
1081   }
1082 }
1083
1084 //===----------------------------------------------------------------------===//
1085 //  Test normalizing/denormalizing
1086 //===----------------------------------------------------------------------===//
1087
1088 LLVM_YAML_STRONG_TYPEDEF(uint32_t, TotalSeconds)
1089
1090 typedef std::vector<TotalSeconds> SecondsSequence;
1091
1092 LLVM_YAML_IS_SEQUENCE_VECTOR(TotalSeconds)
1093
1094
1095 namespace llvm {
1096 namespace yaml {
1097   template <>
1098   struct MappingTraits<TotalSeconds> {
1099
1100     class NormalizedSeconds {
1101     public:
1102       NormalizedSeconds(IO &io)
1103         : hours(0), minutes(0), seconds(0) {
1104       }
1105       NormalizedSeconds(IO &, TotalSeconds &secs)
1106         : hours(secs/3600),
1107           minutes((secs - (hours*3600))/60),
1108           seconds(secs % 60) {
1109       }
1110       TotalSeconds denormalize(IO &) {
1111         return TotalSeconds(hours*3600 + minutes*60 + seconds);
1112       }
1113
1114       uint32_t     hours;
1115       uint8_t      minutes;
1116       uint8_t      seconds;
1117     };
1118
1119     static void mapping(IO &io, TotalSeconds &secs) {
1120       MappingNormalization<NormalizedSeconds, TotalSeconds> keys(io, secs);
1121
1122       io.mapOptional("hours",    keys->hours,    (uint32_t)0);
1123       io.mapOptional("minutes",  keys->minutes,  (uint8_t)0);
1124       io.mapRequired("seconds",  keys->seconds);
1125     }
1126   };
1127 }
1128 }
1129
1130
1131 //
1132 // Test the reading of a yaml sequence of mappings
1133 //
1134 TEST(YAMLIO, TestReadMySecondsSequence) {
1135   SecondsSequence seq;
1136   Input yin("---\n - hours:  1\n   seconds:  5\n - seconds:  59\n...\n");
1137   yin >> seq;
1138
1139   EXPECT_FALSE(yin.error());
1140   EXPECT_EQ(seq.size(), 2UL);
1141   EXPECT_EQ(seq[0], 3605U);
1142   EXPECT_EQ(seq[1], 59U);
1143 }
1144
1145
1146 //
1147 // Test writing then reading back custom values
1148 //
1149 TEST(YAMLIO, TestReadWriteMySecondsSequence) {
1150   std::string intermediate;
1151   {
1152     SecondsSequence seq;
1153     seq.push_back(4000);
1154     seq.push_back(500);
1155     seq.push_back(59);
1156
1157     llvm::raw_string_ostream ostr(intermediate);
1158     Output yout(ostr);
1159     yout << seq;
1160   }
1161   {
1162     Input yin(intermediate);
1163     SecondsSequence seq2;
1164     yin >> seq2;
1165
1166     EXPECT_FALSE(yin.error());
1167     EXPECT_EQ(seq2.size(), 3UL);
1168     EXPECT_EQ(seq2[0], 4000U);
1169     EXPECT_EQ(seq2[1], 500U);
1170     EXPECT_EQ(seq2[2], 59U);
1171   }
1172 }
1173
1174
1175 //===----------------------------------------------------------------------===//
1176 //  Test dynamic typing
1177 //===----------------------------------------------------------------------===//
1178
1179 enum AFlags {
1180     a1,
1181     a2,
1182     a3
1183 };
1184
1185 enum BFlags {
1186     b1,
1187     b2,
1188     b3
1189 };
1190
1191 enum Kind {
1192     kindA,
1193     kindB
1194 };
1195
1196 struct KindAndFlags {
1197   KindAndFlags() : kind(kindA), flags(0) { }
1198   KindAndFlags(Kind k, uint32_t f) : kind(k), flags(f) { }
1199   Kind        kind;
1200   uint32_t    flags;
1201 };
1202
1203 typedef std::vector<KindAndFlags> KindAndFlagsSequence;
1204
1205 LLVM_YAML_IS_SEQUENCE_VECTOR(KindAndFlags)
1206
1207 namespace llvm {
1208 namespace yaml {
1209   template <>
1210   struct ScalarEnumerationTraits<AFlags> {
1211     static void enumeration(IO &io, AFlags &value) {
1212       io.enumCase(value, "a1",  a1);
1213       io.enumCase(value, "a2",  a2);
1214       io.enumCase(value, "a3",  a3);
1215     }
1216   };
1217   template <>
1218   struct ScalarEnumerationTraits<BFlags> {
1219     static void enumeration(IO &io, BFlags &value) {
1220       io.enumCase(value, "b1",  b1);
1221       io.enumCase(value, "b2",  b2);
1222       io.enumCase(value, "b3",  b3);
1223     }
1224   };
1225   template <>
1226   struct ScalarEnumerationTraits<Kind> {
1227     static void enumeration(IO &io, Kind &value) {
1228       io.enumCase(value, "A",  kindA);
1229       io.enumCase(value, "B",  kindB);
1230     }
1231   };
1232   template <>
1233   struct MappingTraits<KindAndFlags> {
1234     static void mapping(IO &io, KindAndFlags& kf) {
1235       io.mapRequired("kind",  kf.kind);
1236       // Type of "flags" field varies depending on "kind" field.
1237       // Use memcpy here to avoid breaking strict aliasing rules.
1238       if (kf.kind == kindA) {
1239         AFlags aflags = static_cast<AFlags>(kf.flags);
1240         io.mapRequired("flags", aflags);
1241         kf.flags = aflags;
1242       } else {
1243         BFlags bflags = static_cast<BFlags>(kf.flags);
1244         io.mapRequired("flags", bflags);
1245         kf.flags = bflags;
1246       }
1247     }
1248   };
1249 }
1250 }
1251
1252
1253 //
1254 // Test the reading of a yaml sequence dynamic types
1255 //
1256 TEST(YAMLIO, TestReadKindAndFlagsSequence) {
1257   KindAndFlagsSequence seq;
1258   Input yin("---\n - kind:  A\n   flags:  a2\n - kind:  B\n   flags:  b1\n...\n");
1259   yin >> seq;
1260
1261   EXPECT_FALSE(yin.error());
1262   EXPECT_EQ(seq.size(), 2UL);
1263   EXPECT_EQ(seq[0].kind,  kindA);
1264   EXPECT_EQ(seq[0].flags, (uint32_t)a2);
1265   EXPECT_EQ(seq[1].kind,  kindB);
1266   EXPECT_EQ(seq[1].flags, (uint32_t)b1);
1267 }
1268
1269 //
1270 // Test writing then reading back dynamic types
1271 //
1272 TEST(YAMLIO, TestReadWriteKindAndFlagsSequence) {
1273   std::string intermediate;
1274   {
1275     KindAndFlagsSequence seq;
1276     seq.push_back(KindAndFlags(kindA,a1));
1277     seq.push_back(KindAndFlags(kindB,b1));
1278     seq.push_back(KindAndFlags(kindA,a2));
1279     seq.push_back(KindAndFlags(kindB,b2));
1280     seq.push_back(KindAndFlags(kindA,a3));
1281
1282     llvm::raw_string_ostream ostr(intermediate);
1283     Output yout(ostr);
1284     yout << seq;
1285   }
1286   {
1287     Input yin(intermediate);
1288     KindAndFlagsSequence seq2;
1289     yin >> seq2;
1290
1291     EXPECT_FALSE(yin.error());
1292     EXPECT_EQ(seq2.size(), 5UL);
1293     EXPECT_EQ(seq2[0].kind,  kindA);
1294     EXPECT_EQ(seq2[0].flags, (uint32_t)a1);
1295     EXPECT_EQ(seq2[1].kind,  kindB);
1296     EXPECT_EQ(seq2[1].flags, (uint32_t)b1);
1297     EXPECT_EQ(seq2[2].kind,  kindA);
1298     EXPECT_EQ(seq2[2].flags, (uint32_t)a2);
1299     EXPECT_EQ(seq2[3].kind,  kindB);
1300     EXPECT_EQ(seq2[3].flags, (uint32_t)b2);
1301     EXPECT_EQ(seq2[4].kind,  kindA);
1302     EXPECT_EQ(seq2[4].flags, (uint32_t)a3);
1303   }
1304 }
1305
1306
1307 //===----------------------------------------------------------------------===//
1308 //  Test document list
1309 //===----------------------------------------------------------------------===//
1310
1311 struct FooBarMap {
1312   int foo;
1313   int bar;
1314 };
1315 typedef std::vector<FooBarMap> FooBarMapDocumentList;
1316
1317 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(FooBarMap)
1318
1319
1320 namespace llvm {
1321 namespace yaml {
1322   template <>
1323   struct MappingTraits<FooBarMap> {
1324     static void mapping(IO &io, FooBarMap& fb) {
1325       io.mapRequired("foo",    fb.foo);
1326       io.mapRequired("bar",    fb.bar);
1327     }
1328   };
1329 }
1330 }
1331
1332
1333 //
1334 // Test the reading of a yaml mapping
1335 //
1336 TEST(YAMLIO, TestDocRead) {
1337   FooBarMap doc;
1338   Input yin("---\nfoo:  3\nbar:  5\n...\n");
1339   yin >> doc;
1340
1341   EXPECT_FALSE(yin.error());
1342   EXPECT_EQ(doc.foo, 3);
1343   EXPECT_EQ(doc.bar,5);
1344 }
1345
1346
1347
1348 //
1349 // Test writing then reading back a sequence of mappings
1350 //
1351 TEST(YAMLIO, TestSequenceDocListWriteAndRead) {
1352   std::string intermediate;
1353   {
1354     FooBarMap doc1;
1355     doc1.foo = 10;
1356     doc1.bar = -3;
1357     FooBarMap doc2;
1358     doc2.foo = 257;
1359     doc2.bar = 0;
1360     std::vector<FooBarMap> docList;
1361     docList.push_back(doc1);
1362     docList.push_back(doc2);
1363
1364     llvm::raw_string_ostream ostr(intermediate);
1365     Output yout(ostr);
1366     yout << docList;
1367   }
1368
1369
1370   {
1371     Input yin(intermediate);
1372     std::vector<FooBarMap> docList2;
1373     yin >> docList2;
1374
1375     EXPECT_FALSE(yin.error());
1376     EXPECT_EQ(docList2.size(), 2UL);
1377     FooBarMap& map1 = docList2[0];
1378     FooBarMap& map2 = docList2[1];
1379     EXPECT_EQ(map1.foo, 10);
1380     EXPECT_EQ(map1.bar, -3);
1381     EXPECT_EQ(map2.foo, 257);
1382     EXPECT_EQ(map2.bar, 0);
1383   }
1384 }
1385
1386 //===----------------------------------------------------------------------===//
1387 //  Test document tags
1388 //===----------------------------------------------------------------------===//
1389
1390 struct MyDouble {
1391   MyDouble() : value(0.0) { }
1392   MyDouble(double x) : value(x) { }
1393   double value;
1394 };
1395
1396 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(MyDouble)
1397
1398
1399 namespace llvm {
1400 namespace yaml {
1401   template <>
1402   struct MappingTraits<MyDouble> {
1403     static void mapping(IO &io, MyDouble &d) {
1404       if (io.mapTag("!decimal", true)) {
1405         mappingDecimal(io, d);
1406       } else if (io.mapTag("!fraction")) {
1407         mappingFraction(io, d);
1408       }
1409     }
1410     static void mappingDecimal(IO &io, MyDouble &d) {
1411       io.mapRequired("value", d.value);
1412     }
1413     static void mappingFraction(IO &io, MyDouble &d) {
1414         double num, denom;
1415         io.mapRequired("numerator",      num);
1416         io.mapRequired("denominator",    denom);
1417         // convert fraction to double
1418         d.value = num/denom;
1419     }
1420   };
1421  }
1422 }
1423
1424
1425 //
1426 // Test the reading of two different tagged yaml documents.
1427 //
1428 TEST(YAMLIO, TestTaggedDocuments) {
1429   std::vector<MyDouble> docList;
1430   Input yin("--- !decimal\nvalue:  3.0\n"
1431             "--- !fraction\nnumerator:  9.0\ndenominator:  2\n...\n");
1432   yin >> docList;
1433   EXPECT_FALSE(yin.error());
1434   EXPECT_EQ(docList.size(), 2UL);
1435   EXPECT_EQ(docList[0].value, 3.0);
1436   EXPECT_EQ(docList[1].value, 4.5);
1437 }
1438
1439
1440
1441 //
1442 // Test writing then reading back tagged documents
1443 //
1444 TEST(YAMLIO, TestTaggedDocumentsWriteAndRead) {
1445   std::string intermediate;
1446   {
1447     MyDouble a(10.25);
1448     MyDouble b(-3.75);
1449     std::vector<MyDouble> docList;
1450     docList.push_back(a);
1451     docList.push_back(b);
1452
1453     llvm::raw_string_ostream ostr(intermediate);
1454     Output yout(ostr);
1455     yout << docList;
1456   }
1457
1458   {
1459     Input yin(intermediate);
1460     std::vector<MyDouble> docList2;
1461     yin >> docList2;
1462
1463     EXPECT_FALSE(yin.error());
1464     EXPECT_EQ(docList2.size(), 2UL);
1465     EXPECT_EQ(docList2[0].value, 10.25);
1466     EXPECT_EQ(docList2[1].value, -3.75);
1467   }
1468 }
1469
1470
1471 //===----------------------------------------------------------------------===//
1472 //  Test mapping validation
1473 //===----------------------------------------------------------------------===//
1474
1475 struct MyValidation {
1476   double value;
1477 };
1478
1479 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(MyValidation)
1480
1481 namespace llvm {
1482 namespace yaml {
1483   template <>
1484   struct MappingTraits<MyValidation> {
1485     static void mapping(IO &io, MyValidation &d) {
1486         io.mapRequired("value", d.value);
1487     }
1488     static StringRef validate(IO &io, MyValidation &d) {
1489         if (d.value < 0)
1490           return "negative value";
1491         return StringRef();
1492     }
1493   };
1494  }
1495 }
1496
1497
1498 //
1499 // Test that validate() is called and complains about the negative value.
1500 //
1501 TEST(YAMLIO, TestValidatingInput) {
1502   std::vector<MyValidation> docList;
1503   Input yin("--- \nvalue:  3.0\n"
1504             "--- \nvalue:  -1.0\n...\n",
1505             nullptr, suppressErrorMessages);
1506   yin >> docList;
1507   EXPECT_TRUE(!!yin.error());
1508 }
1509
1510 //===----------------------------------------------------------------------===//
1511 //  Test flow mapping
1512 //===----------------------------------------------------------------------===//
1513
1514 struct FlowFooBar {
1515   int foo;
1516   int bar;
1517
1518   FlowFooBar() : foo(0), bar(0) {}
1519   FlowFooBar(int foo, int bar) : foo(foo), bar(bar) {}
1520 };
1521
1522 typedef std::vector<FlowFooBar> FlowFooBarSequence;
1523
1524 LLVM_YAML_IS_SEQUENCE_VECTOR(FlowFooBar)
1525
1526 struct FlowFooBarDoc {
1527   FlowFooBar attribute;
1528   FlowFooBarSequence seq;
1529 };
1530
1531 namespace llvm {
1532 namespace yaml {
1533   template <>
1534   struct MappingTraits<FlowFooBar> {
1535     static void mapping(IO &io, FlowFooBar &fb) {
1536       io.mapRequired("foo", fb.foo);
1537       io.mapRequired("bar", fb.bar);
1538     }
1539
1540     static const bool flow = true;
1541   };
1542
1543   template <>
1544   struct MappingTraits<FlowFooBarDoc> {
1545     static void mapping(IO &io, FlowFooBarDoc &fb) {
1546       io.mapRequired("attribute", fb.attribute);
1547       io.mapRequired("seq", fb.seq);
1548     }
1549   };
1550 }
1551 }
1552
1553 //
1554 // Test writing then reading back custom mappings
1555 //
1556 TEST(YAMLIO, TestReadWriteMyFlowMapping) {
1557   std::string intermediate;
1558   {
1559     FlowFooBarDoc doc;
1560     doc.attribute = FlowFooBar(42, 907);
1561     doc.seq.push_back(FlowFooBar(1, 2));
1562     doc.seq.push_back(FlowFooBar(0, 0));
1563     doc.seq.push_back(FlowFooBar(-1, 1024));
1564
1565     llvm::raw_string_ostream ostr(intermediate);
1566     Output yout(ostr);
1567     yout << doc;
1568
1569     // Verify that mappings were written in flow style
1570     ostr.flush();
1571     llvm::StringRef flowOut(intermediate);
1572     EXPECT_NE(llvm::StringRef::npos, flowOut.find("{ foo: 42, bar: 907 }"));
1573     EXPECT_NE(llvm::StringRef::npos, flowOut.find("- { foo: 1, bar: 2 }"));
1574     EXPECT_NE(llvm::StringRef::npos, flowOut.find("- { foo: 0, bar: 0 }"));
1575     EXPECT_NE(llvm::StringRef::npos, flowOut.find("- { foo: -1, bar: 1024 }"));
1576   }
1577
1578   {
1579     Input yin(intermediate);
1580     FlowFooBarDoc doc2;
1581     yin >> doc2;
1582
1583     EXPECT_FALSE(yin.error());
1584     EXPECT_EQ(doc2.attribute.foo, 42);
1585     EXPECT_EQ(doc2.attribute.bar, 907);
1586     EXPECT_EQ(doc2.seq.size(), 3UL);
1587     EXPECT_EQ(doc2.seq[0].foo, 1);
1588     EXPECT_EQ(doc2.seq[0].bar, 2);
1589     EXPECT_EQ(doc2.seq[1].foo, 0);
1590     EXPECT_EQ(doc2.seq[1].bar, 0);
1591     EXPECT_EQ(doc2.seq[2].foo, -1);
1592     EXPECT_EQ(doc2.seq[2].bar, 1024);
1593   }
1594 }
1595
1596 //===----------------------------------------------------------------------===//
1597 //  Test error handling
1598 //===----------------------------------------------------------------------===//
1599
1600 //
1601 // Test error handling of unknown enumerated scalar
1602 //
1603 TEST(YAMLIO, TestColorsReadError) {
1604   ColorMap map;
1605   Input yin("---\n"
1606             "c1:  blue\n"
1607             "c2:  purple\n"
1608             "c3:  green\n"
1609             "...\n",
1610             /*Ctxt=*/nullptr,
1611             suppressErrorMessages);
1612   yin >> map;
1613   EXPECT_TRUE(!!yin.error());
1614 }
1615
1616
1617 //
1618 // Test error handling of flow sequence with unknown value
1619 //
1620 TEST(YAMLIO, TestFlagsReadError) {
1621   FlagsMap map;
1622   Input yin("---\n"
1623             "f1:  [ big ]\n"
1624             "f2:  [ round, hollow ]\n"
1625             "f3:  []\n"
1626             "...\n",
1627             /*Ctxt=*/nullptr,
1628             suppressErrorMessages);
1629   yin >> map;
1630
1631   EXPECT_TRUE(!!yin.error());
1632 }
1633
1634
1635 //
1636 // Test error handling reading built-in uint8_t type
1637 //
1638 LLVM_YAML_IS_SEQUENCE_VECTOR(uint8_t)
1639 TEST(YAMLIO, TestReadBuiltInTypesUint8Error) {
1640   std::vector<uint8_t> seq;
1641   Input yin("---\n"
1642             "- 255\n"
1643             "- 0\n"
1644             "- 257\n"
1645             "...\n",
1646             /*Ctxt=*/nullptr,
1647             suppressErrorMessages);
1648   yin >> seq;
1649
1650   EXPECT_TRUE(!!yin.error());
1651 }
1652
1653
1654 //
1655 // Test error handling reading built-in uint16_t type
1656 //
1657 LLVM_YAML_IS_SEQUENCE_VECTOR(uint16_t)
1658 TEST(YAMLIO, TestReadBuiltInTypesUint16Error) {
1659   std::vector<uint16_t> seq;
1660   Input yin("---\n"
1661             "- 65535\n"
1662             "- 0\n"
1663             "- 66000\n"
1664             "...\n",
1665             /*Ctxt=*/nullptr,
1666             suppressErrorMessages);
1667   yin >> seq;
1668
1669   EXPECT_TRUE(!!yin.error());
1670 }
1671
1672
1673 //
1674 // Test error handling reading built-in uint32_t type
1675 //
1676 LLVM_YAML_IS_SEQUENCE_VECTOR(uint32_t)
1677 TEST(YAMLIO, TestReadBuiltInTypesUint32Error) {
1678   std::vector<uint32_t> seq;
1679   Input yin("---\n"
1680             "- 4000000000\n"
1681             "- 0\n"
1682             "- 5000000000\n"
1683             "...\n",
1684             /*Ctxt=*/nullptr,
1685             suppressErrorMessages);
1686   yin >> seq;
1687
1688   EXPECT_TRUE(!!yin.error());
1689 }
1690
1691
1692 //
1693 // Test error handling reading built-in uint64_t type
1694 //
1695 LLVM_YAML_IS_SEQUENCE_VECTOR(uint64_t)
1696 TEST(YAMLIO, TestReadBuiltInTypesUint64Error) {
1697   std::vector<uint64_t> seq;
1698   Input yin("---\n"
1699             "- 18446744073709551615\n"
1700             "- 0\n"
1701             "- 19446744073709551615\n"
1702             "...\n",
1703             /*Ctxt=*/nullptr,
1704             suppressErrorMessages);
1705   yin >> seq;
1706
1707   EXPECT_TRUE(!!yin.error());
1708 }
1709
1710
1711 //
1712 // Test error handling reading built-in int8_t type
1713 //
1714 LLVM_YAML_IS_SEQUENCE_VECTOR(int8_t)
1715 TEST(YAMLIO, TestReadBuiltInTypesint8OverError) {
1716   std::vector<int8_t> seq;
1717   Input yin("---\n"
1718             "- -128\n"
1719             "- 0\n"
1720             "- 127\n"
1721             "- 128\n"
1722            "...\n",
1723             /*Ctxt=*/nullptr,
1724             suppressErrorMessages);
1725   yin >> seq;
1726
1727   EXPECT_TRUE(!!yin.error());
1728 }
1729
1730 //
1731 // Test error handling reading built-in int8_t type
1732 //
1733 TEST(YAMLIO, TestReadBuiltInTypesint8UnderError) {
1734   std::vector<int8_t> seq;
1735   Input yin("---\n"
1736             "- -128\n"
1737             "- 0\n"
1738             "- 127\n"
1739             "- -129\n"
1740             "...\n",
1741             /*Ctxt=*/nullptr,
1742             suppressErrorMessages);
1743   yin >> seq;
1744
1745   EXPECT_TRUE(!!yin.error());
1746 }
1747
1748
1749 //
1750 // Test error handling reading built-in int16_t type
1751 //
1752 LLVM_YAML_IS_SEQUENCE_VECTOR(int16_t)
1753 TEST(YAMLIO, TestReadBuiltInTypesint16UnderError) {
1754   std::vector<int16_t> seq;
1755   Input yin("---\n"
1756             "- 32767\n"
1757             "- 0\n"
1758             "- -32768\n"
1759             "- -32769\n"
1760             "...\n",
1761             /*Ctxt=*/nullptr,
1762             suppressErrorMessages);
1763   yin >> seq;
1764
1765   EXPECT_TRUE(!!yin.error());
1766 }
1767
1768
1769 //
1770 // Test error handling reading built-in int16_t type
1771 //
1772 TEST(YAMLIO, TestReadBuiltInTypesint16OverError) {
1773   std::vector<int16_t> seq;
1774   Input yin("---\n"
1775             "- 32767\n"
1776             "- 0\n"
1777             "- -32768\n"
1778             "- 32768\n"
1779             "...\n",
1780             /*Ctxt=*/nullptr,
1781             suppressErrorMessages);
1782   yin >> seq;
1783
1784   EXPECT_TRUE(!!yin.error());
1785 }
1786
1787
1788 //
1789 // Test error handling reading built-in int32_t type
1790 //
1791 LLVM_YAML_IS_SEQUENCE_VECTOR(int32_t)
1792 TEST(YAMLIO, TestReadBuiltInTypesint32UnderError) {
1793   std::vector<int32_t> seq;
1794   Input yin("---\n"
1795             "- 2147483647\n"
1796             "- 0\n"
1797             "- -2147483648\n"
1798             "- -2147483649\n"
1799             "...\n",
1800             /*Ctxt=*/nullptr,
1801             suppressErrorMessages);
1802   yin >> seq;
1803
1804   EXPECT_TRUE(!!yin.error());
1805 }
1806
1807 //
1808 // Test error handling reading built-in int32_t type
1809 //
1810 TEST(YAMLIO, TestReadBuiltInTypesint32OverError) {
1811   std::vector<int32_t> seq;
1812   Input yin("---\n"
1813             "- 2147483647\n"
1814             "- 0\n"
1815             "- -2147483648\n"
1816             "- 2147483649\n"
1817             "...\n",
1818             /*Ctxt=*/nullptr,
1819             suppressErrorMessages);
1820   yin >> seq;
1821
1822   EXPECT_TRUE(!!yin.error());
1823 }
1824
1825
1826 //
1827 // Test error handling reading built-in int64_t type
1828 //
1829 LLVM_YAML_IS_SEQUENCE_VECTOR(int64_t)
1830 TEST(YAMLIO, TestReadBuiltInTypesint64UnderError) {
1831   std::vector<int64_t> seq;
1832   Input yin("---\n"
1833             "- -9223372036854775808\n"
1834             "- 0\n"
1835             "- 9223372036854775807\n"
1836             "- -9223372036854775809\n"
1837             "...\n",
1838             /*Ctxt=*/nullptr,
1839             suppressErrorMessages);
1840   yin >> seq;
1841
1842   EXPECT_TRUE(!!yin.error());
1843 }
1844
1845 //
1846 // Test error handling reading built-in int64_t type
1847 //
1848 TEST(YAMLIO, TestReadBuiltInTypesint64OverError) {
1849   std::vector<int64_t> seq;
1850   Input yin("---\n"
1851             "- -9223372036854775808\n"
1852             "- 0\n"
1853             "- 9223372036854775807\n"
1854             "- 9223372036854775809\n"
1855             "...\n",
1856             /*Ctxt=*/nullptr,
1857             suppressErrorMessages);
1858   yin >> seq;
1859
1860   EXPECT_TRUE(!!yin.error());
1861 }
1862
1863 //
1864 // Test error handling reading built-in float type
1865 //
1866 LLVM_YAML_IS_SEQUENCE_VECTOR(float)
1867 TEST(YAMLIO, TestReadBuiltInTypesFloatError) {
1868   std::vector<float> seq;
1869   Input yin("---\n"
1870             "- 0.0\n"
1871             "- 1000.1\n"
1872             "- -123.456\n"
1873             "- 1.2.3\n"
1874             "...\n",
1875             /*Ctxt=*/nullptr,
1876             suppressErrorMessages);
1877   yin >> seq;
1878
1879   EXPECT_TRUE(!!yin.error());
1880 }
1881
1882 //
1883 // Test error handling reading built-in float type
1884 //
1885 LLVM_YAML_IS_SEQUENCE_VECTOR(double)
1886 TEST(YAMLIO, TestReadBuiltInTypesDoubleError) {
1887   std::vector<double> seq;
1888   Input yin("---\n"
1889             "- 0.0\n"
1890             "- 1000.1\n"
1891             "- -123.456\n"
1892             "- 1.2.3\n"
1893             "...\n",
1894             /*Ctxt=*/nullptr,
1895             suppressErrorMessages);
1896   yin >> seq;
1897
1898   EXPECT_TRUE(!!yin.error());
1899 }
1900
1901 //
1902 // Test error handling reading built-in Hex8 type
1903 //
1904 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex8)
1905 TEST(YAMLIO, TestReadBuiltInTypesHex8Error) {
1906   std::vector<Hex8> seq;
1907   Input yin("---\n"
1908             "- 0x12\n"
1909             "- 0xFE\n"
1910             "- 0x123\n"
1911             "...\n",
1912             /*Ctxt=*/nullptr,
1913             suppressErrorMessages);
1914   yin >> seq;
1915
1916   EXPECT_TRUE(!!yin.error());
1917 }
1918
1919
1920 //
1921 // Test error handling reading built-in Hex16 type
1922 //
1923 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex16)
1924 TEST(YAMLIO, TestReadBuiltInTypesHex16Error) {
1925   std::vector<Hex16> seq;
1926   Input yin("---\n"
1927             "- 0x0012\n"
1928             "- 0xFEFF\n"
1929             "- 0x12345\n"
1930             "...\n",
1931             /*Ctxt=*/nullptr,
1932             suppressErrorMessages);
1933   yin >> seq;
1934
1935   EXPECT_TRUE(!!yin.error());
1936 }
1937
1938 //
1939 // Test error handling reading built-in Hex32 type
1940 //
1941 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex32)
1942 TEST(YAMLIO, TestReadBuiltInTypesHex32Error) {
1943   std::vector<Hex32> seq;
1944   Input yin("---\n"
1945             "- 0x0012\n"
1946             "- 0xFEFF0000\n"
1947             "- 0x1234556789\n"
1948             "...\n",
1949             /*Ctxt=*/nullptr,
1950             suppressErrorMessages);
1951   yin >> seq;
1952
1953   EXPECT_TRUE(!!yin.error());
1954 }
1955
1956 //
1957 // Test error handling reading built-in Hex64 type
1958 //
1959 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex64)
1960 TEST(YAMLIO, TestReadBuiltInTypesHex64Error) {
1961   std::vector<Hex64> seq;
1962   Input yin("---\n"
1963             "- 0x0012\n"
1964             "- 0xFFEEDDCCBBAA9988\n"
1965             "- 0x12345567890ABCDEF0\n"
1966             "...\n",
1967             /*Ctxt=*/nullptr,
1968             suppressErrorMessages);
1969   yin >> seq;
1970
1971   EXPECT_TRUE(!!yin.error());
1972 }
1973
1974 TEST(YAMLIO, TestMalformedMapFailsGracefully) {
1975   FooBar doc;
1976   {
1977     // We pass the suppressErrorMessages handler to handle the error
1978     // message generated in the constructor of Input.
1979     Input yin("{foo:3, bar: 5}", /*Ctxt=*/nullptr, suppressErrorMessages);
1980     yin >> doc;
1981     EXPECT_TRUE(!!yin.error());
1982   }
1983
1984   {
1985     Input yin("---\nfoo:3\nbar: 5\n...\n", /*Ctxt=*/nullptr, suppressErrorMessages);
1986     yin >> doc;
1987     EXPECT_TRUE(!!yin.error());
1988   }
1989 }
1990
1991 struct OptionalTest {
1992   std::vector<int> Numbers;
1993 };
1994
1995 struct OptionalTestSeq {
1996   std::vector<OptionalTest> Tests;
1997 };
1998
1999 LLVM_YAML_IS_SEQUENCE_VECTOR(OptionalTest)
2000 namespace llvm {
2001 namespace yaml {
2002   template <>
2003   struct MappingTraits<OptionalTest> {
2004     static void mapping(IO& IO, OptionalTest &OT) {
2005       IO.mapOptional("Numbers", OT.Numbers);
2006     }
2007   };
2008
2009   template <>
2010   struct MappingTraits<OptionalTestSeq> {
2011     static void mapping(IO &IO, OptionalTestSeq &OTS) {
2012       IO.mapOptional("Tests", OTS.Tests);
2013     }
2014   };
2015 }
2016 }
2017
2018 TEST(YAMLIO, SequenceElideTest) {
2019   // Test that writing out a purely optional structure with its fields set to
2020   // default followed by other data is properly read back in.
2021   OptionalTestSeq Seq;
2022   OptionalTest One, Two, Three, Four;
2023   int N[] = {1, 2, 3};
2024   Three.Numbers.assign(N, N + 3);
2025   Seq.Tests.push_back(One);
2026   Seq.Tests.push_back(Two);
2027   Seq.Tests.push_back(Three);
2028   Seq.Tests.push_back(Four);
2029
2030   std::string intermediate;
2031   {
2032     llvm::raw_string_ostream ostr(intermediate);
2033     Output yout(ostr);
2034     yout << Seq;
2035   }
2036
2037   Input yin(intermediate);
2038   OptionalTestSeq Seq2;
2039   yin >> Seq2;
2040
2041   EXPECT_FALSE(yin.error());
2042
2043   EXPECT_EQ(4UL, Seq2.Tests.size());
2044
2045   EXPECT_TRUE(Seq2.Tests[0].Numbers.empty());
2046   EXPECT_TRUE(Seq2.Tests[1].Numbers.empty());
2047
2048   EXPECT_EQ(1, Seq2.Tests[2].Numbers[0]);
2049   EXPECT_EQ(2, Seq2.Tests[2].Numbers[1]);
2050   EXPECT_EQ(3, Seq2.Tests[2].Numbers[2]);
2051
2052   EXPECT_TRUE(Seq2.Tests[3].Numbers.empty());
2053 }
2054
2055 TEST(YAMLIO, TestEmptyStringFailsForMapWithRequiredFields) {
2056   FooBar doc;
2057   Input yin("");
2058   yin >> doc;
2059   EXPECT_TRUE(!!yin.error());
2060 }
2061
2062 TEST(YAMLIO, TestEmptyStringSucceedsForMapWithOptionalFields) {
2063   OptionalTest doc;
2064   Input yin("");
2065   yin >> doc;
2066   EXPECT_FALSE(yin.error());
2067 }
2068
2069 TEST(YAMLIO, TestEmptyStringSucceedsForSequence) {
2070   std::vector<uint8_t> seq;
2071   Input yin("", /*Ctxt=*/nullptr, suppressErrorMessages);
2072   yin >> seq;
2073
2074   EXPECT_FALSE(yin.error());
2075   EXPECT_TRUE(seq.empty());
2076 }
2077
2078 struct FlowMap {
2079   llvm::StringRef str1, str2, str3;
2080   FlowMap(llvm::StringRef str1, llvm::StringRef str2, llvm::StringRef str3)
2081     : str1(str1), str2(str2), str3(str3) {}
2082 };
2083
2084 struct FlowSeq {
2085   llvm::StringRef str;
2086   FlowSeq(llvm::StringRef S) : str(S) {}
2087   FlowSeq() = default;
2088 };
2089
2090 namespace llvm {
2091 namespace yaml {
2092   template <>
2093   struct MappingTraits<FlowMap> {
2094     static void mapping(IO &io, FlowMap &fm) {
2095       io.mapRequired("str1", fm.str1);
2096       io.mapRequired("str2", fm.str2);
2097       io.mapRequired("str3", fm.str3);
2098     }
2099
2100     static const bool flow = true;
2101   };
2102
2103 template <>
2104 struct ScalarTraits<FlowSeq> {
2105   static void output(const FlowSeq &value, void*, llvm::raw_ostream &out) {
2106     out << value.str;
2107   }
2108   static StringRef input(StringRef scalar, void*, FlowSeq &value) {
2109     value.str = scalar;
2110     return "";
2111   }
2112
2113   static bool mustQuote(StringRef S) { return false; }
2114 };
2115 }
2116 }
2117
2118 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FlowSeq)
2119
2120 TEST(YAMLIO, TestWrapFlow) {
2121   std::string out;
2122   llvm::raw_string_ostream ostr(out);
2123   FlowMap Map("This is str1", "This is str2", "This is str3");
2124   std::vector<FlowSeq> Seq;
2125   Seq.emplace_back("This is str1");
2126   Seq.emplace_back("This is str2");
2127   Seq.emplace_back("This is str3");
2128
2129   {
2130     // 20 is just bellow the total length of the first mapping field.
2131     // We should wreap at every element.
2132     Output yout(ostr, nullptr, 15);
2133
2134     yout << Map;
2135     ostr.flush();
2136     EXPECT_EQ(out,
2137               "---\n"
2138               "{ str1: This is str1, \n"
2139               "  str2: This is str2, \n"
2140               "  str3: This is str3 }\n"
2141               "...\n");
2142     out.clear();
2143
2144     yout << Seq;
2145     ostr.flush();
2146     EXPECT_EQ(out,
2147               "---\n"
2148               "[ This is str1, \n"
2149               "  This is str2, \n"
2150               "  This is str3 ]\n"
2151               "...\n");
2152     out.clear();
2153   }
2154   {
2155     // 25 will allow the second field to be output on the first line.
2156     Output yout(ostr, nullptr, 25);
2157
2158     yout << Map;
2159     ostr.flush();
2160     EXPECT_EQ(out,
2161               "---\n"
2162               "{ str1: This is str1, str2: This is str2, \n"
2163               "  str3: This is str3 }\n"
2164               "...\n");
2165     out.clear();
2166
2167     yout << Seq;
2168     ostr.flush();
2169     EXPECT_EQ(out,
2170               "---\n"
2171               "[ This is str1, This is str2, \n"
2172               "  This is str3 ]\n"
2173               "...\n");
2174     out.clear();
2175   }
2176   {
2177     // 0 means no wrapping.
2178     Output yout(ostr, nullptr, 0);
2179
2180     yout << Map;
2181     ostr.flush();
2182     EXPECT_EQ(out,
2183               "---\n"
2184               "{ str1: This is str1, str2: This is str2, str3: This is str3 }\n"
2185               "...\n");
2186     out.clear();
2187
2188     yout << Seq;
2189     ostr.flush();
2190     EXPECT_EQ(out,
2191               "---\n"
2192               "[ This is str1, This is str2, This is str3 ]\n"
2193               "...\n");
2194     out.clear();
2195   }
2196 }