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 flow sequences
 784 //===----------------------------------------------------------------------===//
 785
 786 LLVM_YAML_STRONG_TYPEDEF(int, MyNumber)
 787 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(MyNumber)
 788 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::StringRef)
 789
 790 namespace llvm {
 791 namespace yaml {
 792   template<>
 793   struct ScalarTraits<MyNumber> {
 794     static void output(const MyNumber &value, void *, llvm::raw_ostream &out) {
 795       out << value;
 796     }
 797
 798     static StringRef input(StringRef scalar, void *, MyNumber &value) {
 799       long long n;
 800       if ( getAsSignedInteger(scalar, 0, n) )
 801         return "invalid number";
 802       value = n;
 803       return StringRef();
 804     }
 805
 806     static bool mustQuote(StringRef) { return false; }
 807   };
 808 }
 809 }
 810
 811 struct NameAndNumbers {
 812   llvm::StringRef               name;
 813   std::vector<llvm::StringRef>  strings;
 814   std::vector<MyNumber>         single;
 815   std::vector<MyNumber>         numbers;
 816 };
 817
 818 namespace llvm {
 819 namespace yaml {
 820   template <>
 821   struct MappingTraits<NameAndNumbers> {
 822     static void mapping(IO &io, NameAndNumbers& nn) {
 823       io.mapRequired("name",     nn.name);
 824       io.mapRequired("strings",  nn.strings);
 825       io.mapRequired("single",   nn.single);
 826       io.mapRequired("numbers",  nn.numbers);
 827     }
 828   };
 829 }
 830 }
 831
 832
 833 //
 834 // Test writing then reading back custom values
 835 //
 836 TEST(YAMLIO, TestReadWriteMyFlowSequence) {
 837   std::string intermediate;
 838   {
 839     NameAndNumbers map;
 840     map.name  = "hello";
 841     map.strings.push_back(llvm::StringRef("one"));
 842     map.strings.push_back(llvm::StringRef("two"));
 843     map.single.push_back(1);
 844     map.numbers.push_back(10);
 845     map.numbers.push_back(-30);
 846     map.numbers.push_back(1024);
 847
 848     llvm::raw_string_ostream ostr(intermediate);
 849     Output yout(ostr);
 850     yout << map;
 851
 852     // Verify sequences were written in flow style
 853     ostr.flush();
 854     llvm::StringRef flowOut(intermediate);
 855     EXPECT_NE(llvm::StringRef::npos, flowOut.find("one, two"));
 856     EXPECT_NE(llvm::StringRef::npos, flowOut.find("10, -30, 1024"));
 857   }
 858
 859   {
 860     Input yin(intermediate);
 861     NameAndNumbers map2;
 862     yin >> map2;
 863
 864     EXPECT_FALSE(yin.error());
 865     EXPECT_TRUE(map2.name.equals("hello"));
 866     EXPECT_EQ(map2.strings.size(), 2UL);
 867     EXPECT_TRUE(map2.strings[0].equals("one"));
 868     EXPECT_TRUE(map2.strings[1].equals("two"));
 869     EXPECT_EQ(map2.single.size(), 1UL);
 870     EXPECT_EQ(1,       map2.single[0]);
 871     EXPECT_EQ(map2.numbers.size(), 3UL);
 872     EXPECT_EQ(10,      map2.numbers[0]);
 873     EXPECT_EQ(-30,     map2.numbers[1]);
 874     EXPECT_EQ(1024,    map2.numbers[2]);
 875   }
 876 }
 877
 878
 879 //===----------------------------------------------------------------------===//
 880 //  Test normalizing/denormalizing
 881 //===----------------------------------------------------------------------===//
 882
 883 LLVM_YAML_STRONG_TYPEDEF(uint32_t, TotalSeconds)
 884
 885 typedef std::vector<TotalSeconds> SecondsSequence;
 886
 887 LLVM_YAML_IS_SEQUENCE_VECTOR(TotalSeconds)
 888
 889
 890 namespace llvm {
 891 namespace yaml {
 892   template <>
 893   struct MappingTraits<TotalSeconds> {
 894
 895     class NormalizedSeconds {
 896     public:
 897       NormalizedSeconds(IO &io)
 898         : hours(0), minutes(0), seconds(0) {
 899       }
 900       NormalizedSeconds(IO &, TotalSeconds &secs)
 901         : hours(secs/3600),
 902           minutes((secs - (hours*3600))/60),
 903           seconds(secs % 60) {
 904       }
 905       TotalSeconds denormalize(IO &) {
 906         return TotalSeconds(hours*3600 + minutes*60 + seconds);
 907       }
 908
 909       uint32_t     hours;
 910       uint8_t      minutes;
 911       uint8_t      seconds;
 912     };
 913
 914     static void mapping(IO &io, TotalSeconds &secs) {
 915       MappingNormalization<NormalizedSeconds, TotalSeconds> keys(io, secs);
 916
 917       io.mapOptional("hours",    keys->hours,    (uint32_t)0);
 918       io.mapOptional("minutes",  keys->minutes,  (uint8_t)0);
 919       io.mapRequired("seconds",  keys->seconds);
 920     }
 921   };
 922 }
 923 }
 924
 925
 926 //
 927 // Test the reading of a yaml sequence of mappings
 928 //
 929 TEST(YAMLIO, TestReadMySecondsSequence) {
 930   SecondsSequence seq;
 931   Input yin("---\n - hours:  1\n   seconds:  5\n - seconds:  59\n...\n");
 932   yin >> seq;
 933
 934   EXPECT_FALSE(yin.error());
 935   EXPECT_EQ(seq.size(), 2UL);
 936   EXPECT_EQ(seq[0], 3605U);
 937   EXPECT_EQ(seq[1], 59U);
 938 }
 939
 940
 941 //
 942 // Test writing then reading back custom values
 943 //
 944 TEST(YAMLIO, TestReadWriteMySecondsSequence) {
 945   std::string intermediate;
 946   {
 947     SecondsSequence seq;
 948     seq.push_back(4000);
 949     seq.push_back(500);
 950     seq.push_back(59);
 951
 952     llvm::raw_string_ostream ostr(intermediate);
 953     Output yout(ostr);
 954     yout << seq;
 955   }
 956   {
 957     Input yin(intermediate);
 958     SecondsSequence seq2;
 959     yin >> seq2;
 960
 961     EXPECT_FALSE(yin.error());
 962     EXPECT_EQ(seq2.size(), 3UL);
 963     EXPECT_EQ(seq2[0], 4000U);
 964     EXPECT_EQ(seq2[1], 500U);
 965     EXPECT_EQ(seq2[2], 59U);
 966   }
 967 }
 968
 969
 970 //===----------------------------------------------------------------------===//
 971 //  Test dynamic typing
 972 //===----------------------------------------------------------------------===//
 973
 974 enum AFlags {
 975     a1,
 976     a2,
 977     a3
 978 };
 979
 980 enum BFlags {
 981     b1,
 982     b2,
 983     b3
 984 };
 985
 986 enum Kind {
 987     kindA,
 988     kindB
 989 };
 990
 991 struct KindAndFlags {
 992   KindAndFlags() : kind(kindA), flags(0) { }
 993   KindAndFlags(Kind k, uint32_t f) : kind(k), flags(f) { }
 994   Kind        kind;
 995   uint32_t    flags;
 996 };
 997
 998 typedef std::vector<KindAndFlags> KindAndFlagsSequence;
 999
1000 LLVM_YAML_IS_SEQUENCE_VECTOR(KindAndFlags)
1001
1002 namespace llvm {
1003 namespace yaml {
1004   template <>
1005   struct ScalarEnumerationTraits<AFlags> {
1006     static void enumeration(IO &io, AFlags &value) {
1007       io.enumCase(value, "a1",  a1);
1008       io.enumCase(value, "a2",  a2);
1009       io.enumCase(value, "a3",  a3);
1010     }
1011   };
1012   template <>
1013   struct ScalarEnumerationTraits<BFlags> {
1014     static void enumeration(IO &io, BFlags &value) {
1015       io.enumCase(value, "b1",  b1);
1016       io.enumCase(value, "b2",  b2);
1017       io.enumCase(value, "b3",  b3);
1018     }
1019   };
1020   template <>
1021   struct ScalarEnumerationTraits<Kind> {
1022     static void enumeration(IO &io, Kind &value) {
1023       io.enumCase(value, "A",  kindA);
1024       io.enumCase(value, "B",  kindB);
1025     }
1026   };
1027   template <>
1028   struct MappingTraits<KindAndFlags> {
1029     static void mapping(IO &io, KindAndFlags& kf) {
1030       io.mapRequired("kind",  kf.kind);
1031       // Type of "flags" field varies depending on "kind" field.
1032       // Use memcpy here to avoid breaking strict aliasing rules.
1033       if (kf.kind == kindA) {
1034         AFlags aflags = static_cast<AFlags>(kf.flags);
1035         io.mapRequired("flags", aflags);
1036         kf.flags = aflags;
1037       } else {
1038         BFlags bflags = static_cast<BFlags>(kf.flags);
1039         io.mapRequired("flags", bflags);
1040         kf.flags = bflags;
1041       }
1042     }
1043   };
1044 }
1045 }
1046
1047
1048 //
1049 // Test the reading of a yaml sequence dynamic types
1050 //
1051 TEST(YAMLIO, TestReadKindAndFlagsSequence) {
1052   KindAndFlagsSequence seq;
1053   Input yin("---\n - kind:  A\n   flags:  a2\n - kind:  B\n   flags:  b1\n...\n");
1054   yin >> seq;
1055
1056   EXPECT_FALSE(yin.error());
1057   EXPECT_EQ(seq.size(), 2UL);
1058   EXPECT_EQ(seq[0].kind,  kindA);
1059   EXPECT_EQ(seq[0].flags, (uint32_t)a2);
1060   EXPECT_EQ(seq[1].kind,  kindB);
1061   EXPECT_EQ(seq[1].flags, (uint32_t)b1);
1062 }
1063
1064 //
1065 // Test writing then reading back dynamic types
1066 //
1067 TEST(YAMLIO, TestReadWriteKindAndFlagsSequence) {
1068   std::string intermediate;
1069   {
1070     KindAndFlagsSequence seq;
1071     seq.push_back(KindAndFlags(kindA,a1));
1072     seq.push_back(KindAndFlags(kindB,b1));
1073     seq.push_back(KindAndFlags(kindA,a2));
1074     seq.push_back(KindAndFlags(kindB,b2));
1075     seq.push_back(KindAndFlags(kindA,a3));
1076
1077     llvm::raw_string_ostream ostr(intermediate);
1078     Output yout(ostr);
1079     yout << seq;
1080   }
1081   {
1082     Input yin(intermediate);
1083     KindAndFlagsSequence seq2;
1084     yin >> seq2;
1085
1086     EXPECT_FALSE(yin.error());
1087     EXPECT_EQ(seq2.size(), 5UL);
1088     EXPECT_EQ(seq2[0].kind,  kindA);
1089     EXPECT_EQ(seq2[0].flags, (uint32_t)a1);
1090     EXPECT_EQ(seq2[1].kind,  kindB);
1091     EXPECT_EQ(seq2[1].flags, (uint32_t)b1);
1092     EXPECT_EQ(seq2[2].kind,  kindA);
1093     EXPECT_EQ(seq2[2].flags, (uint32_t)a2);
1094     EXPECT_EQ(seq2[3].kind,  kindB);
1095     EXPECT_EQ(seq2[3].flags, (uint32_t)b2);
1096     EXPECT_EQ(seq2[4].kind,  kindA);
1097     EXPECT_EQ(seq2[4].flags, (uint32_t)a3);
1098   }
1099 }
1100
1101
1102 //===----------------------------------------------------------------------===//
1103 //  Test document list
1104 //===----------------------------------------------------------------------===//
1105
1106 struct FooBarMap {
1107   int foo;
1108   int bar;
1109 };
1110 typedef std::vector<FooBarMap> FooBarMapDocumentList;
1111
1112 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(FooBarMap)
1113
1114
1115 namespace llvm {
1116 namespace yaml {
1117   template <>
1118   struct MappingTraits<FooBarMap> {
1119     static void mapping(IO &io, FooBarMap& fb) {
1120       io.mapRequired("foo",    fb.foo);
1121       io.mapRequired("bar",    fb.bar);
1122     }
1123   };
1124 }
1125 }
1126
1127
1128 //
1129 // Test the reading of a yaml mapping
1130 //
1131 TEST(YAMLIO, TestDocRead) {
1132   FooBarMap doc;
1133   Input yin("---\nfoo:  3\nbar:  5\n...\n");
1134   yin >> doc;
1135
1136   EXPECT_FALSE(yin.error());
1137   EXPECT_EQ(doc.foo, 3);
1138   EXPECT_EQ(doc.bar,5);
1139 }
1140
1141
1142
1143 //
1144 // Test writing then reading back a sequence of mappings
1145 //
1146 TEST(YAMLIO, TestSequenceDocListWriteAndRead) {
1147   std::string intermediate;
1148   {
1149     FooBarMap doc1;
1150     doc1.foo = 10;
1151     doc1.bar = -3;
1152     FooBarMap doc2;
1153     doc2.foo = 257;
1154     doc2.bar = 0;
1155     std::vector<FooBarMap> docList;
1156     docList.push_back(doc1);
1157     docList.push_back(doc2);
1158
1159     llvm::raw_string_ostream ostr(intermediate);
1160     Output yout(ostr);
1161     yout << docList;
1162   }
1163
1164
1165   {
1166     Input yin(intermediate);
1167     std::vector<FooBarMap> docList2;
1168     yin >> docList2;
1169
1170     EXPECT_FALSE(yin.error());
1171     EXPECT_EQ(docList2.size(), 2UL);
1172     FooBarMap& map1 = docList2[0];
1173     FooBarMap& map2 = docList2[1];
1174     EXPECT_EQ(map1.foo, 10);
1175     EXPECT_EQ(map1.bar, -3);
1176     EXPECT_EQ(map2.foo, 257);
1177     EXPECT_EQ(map2.bar, 0);
1178   }
1179 }
1180
1181 //===----------------------------------------------------------------------===//
1182 //  Test document tags
1183 //===----------------------------------------------------------------------===//
1184
1185 struct MyDouble {
1186   MyDouble() : value(0.0) { }
1187   MyDouble(double x) : value(x) { }
1188   double value;
1189 };
1190
1191 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(MyDouble)
1192
1193
1194 namespace llvm {
1195 namespace yaml {
1196   template <>
1197   struct MappingTraits<MyDouble> {
1198     static void mapping(IO &io, MyDouble &d) {
1199       if (io.mapTag("!decimal", true)) {
1200         mappingDecimal(io, d);
1201       } else if (io.mapTag("!fraction")) {
1202         mappingFraction(io, d);
1203       }
1204     }
1205     static void mappingDecimal(IO &io, MyDouble &d) {
1206       io.mapRequired("value", d.value);
1207     }
1208     static void mappingFraction(IO &io, MyDouble &d) {
1209         double num, denom;
1210         io.mapRequired("numerator",      num);
1211         io.mapRequired("denominator",    denom);
1212         // convert fraction to double
1213         d.value = num/denom;
1214     }
1215   };
1216  }
1217 }
1218
1219
1220 //
1221 // Test the reading of two different tagged yaml documents.
1222 //
1223 TEST(YAMLIO, TestTaggedDocuments) {
1224   std::vector<MyDouble> docList;
1225   Input yin("--- !decimal\nvalue:  3.0\n"
1226             "--- !fraction\nnumerator:  9.0\ndenominator:  2\n...\n");
1227   yin >> docList;
1228   EXPECT_FALSE(yin.error());
1229   EXPECT_EQ(docList.size(), 2UL);
1230   EXPECT_EQ(docList[0].value, 3.0);
1231   EXPECT_EQ(docList[1].value, 4.5);
1232 }
1233
1234
1235
1236 //
1237 // Test writing then reading back tagged documents
1238 //
1239 TEST(YAMLIO, TestTaggedDocumentsWriteAndRead) {
1240   std::string intermediate;
1241   {
1242     MyDouble a(10.25);
1243     MyDouble b(-3.75);
1244     std::vector<MyDouble> docList;
1245     docList.push_back(a);
1246     docList.push_back(b);
1247
1248     llvm::raw_string_ostream ostr(intermediate);
1249     Output yout(ostr);
1250     yout << docList;
1251   }
1252
1253   {
1254     Input yin(intermediate);
1255     std::vector<MyDouble> docList2;
1256     yin >> docList2;
1257
1258     EXPECT_FALSE(yin.error());
1259     EXPECT_EQ(docList2.size(), 2UL);
1260     EXPECT_EQ(docList2[0].value, 10.25);
1261     EXPECT_EQ(docList2[1].value, -3.75);
1262   }
1263 }
1264
1265
1266 //===----------------------------------------------------------------------===//
1267 //  Test mapping validation
1268 //===----------------------------------------------------------------------===//
1269
1270 struct MyValidation {
1271   double value;
1272 };
1273
1274 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(MyValidation)
1275
1276 namespace llvm {
1277 namespace yaml {
1278   template <>
1279   struct MappingTraits<MyValidation> {
1280     static void mapping(IO &io, MyValidation &d) {
1281         io.mapRequired("value", d.value);
1282     }
1283     static StringRef validate(IO &io, MyValidation &d) {
1284         if (d.value < 0)
1285           return "negative value";
1286         return StringRef();
1287     }
1288   };
1289  }
1290 }
1291
1292
1293 //
1294 // Test that validate() is called and complains about the negative value.
1295 //
1296 TEST(YAMLIO, TestValidatingInput) {
1297   std::vector<MyValidation> docList;
1298   Input yin("--- \nvalue:  3.0\n"
1299             "--- \nvalue:  -1.0\n...\n",
1300             nullptr, suppressErrorMessages);
1301   yin >> docList;
1302   EXPECT_TRUE(!!yin.error());
1303 }
1304
1305
1306 //===----------------------------------------------------------------------===//
1307 //  Test error handling
1308 //===----------------------------------------------------------------------===//
1309
1310 //
1311 // Test error handling of unknown enumerated scalar
1312 //
1313 TEST(YAMLIO, TestColorsReadError) {
1314   ColorMap map;
1315   Input yin("---\n"
1316             "c1:  blue\n"
1317             "c2:  purple\n"
1318             "c3:  green\n"
1319             "...\n",
1320             /*Ctxt=*/nullptr,
1321             suppressErrorMessages);
1322   yin >> map;
1323   EXPECT_TRUE(!!yin.error());
1324 }
1325
1326
1327 //
1328 // Test error handling of flow sequence with unknown value
1329 //
1330 TEST(YAMLIO, TestFlagsReadError) {
1331   FlagsMap map;
1332   Input yin("---\n"
1333             "f1:  [ big ]\n"
1334             "f2:  [ round, hollow ]\n"
1335             "f3:  []\n"
1336             "...\n",
1337             /*Ctxt=*/nullptr,
1338             suppressErrorMessages);
1339   yin >> map;
1340
1341   EXPECT_TRUE(!!yin.error());
1342 }
1343
1344
1345 //
1346 // Test error handling reading built-in uint8_t type
1347 //
1348 LLVM_YAML_IS_SEQUENCE_VECTOR(uint8_t)
1349 TEST(YAMLIO, TestReadBuiltInTypesUint8Error) {
1350   std::vector<uint8_t> seq;
1351   Input yin("---\n"
1352             "- 255\n"
1353             "- 0\n"
1354             "- 257\n"
1355             "...\n",
1356             /*Ctxt=*/nullptr,
1357             suppressErrorMessages);
1358   yin >> seq;
1359
1360   EXPECT_TRUE(!!yin.error());
1361 }
1362
1363
1364 //
1365 // Test error handling reading built-in uint16_t type
1366 //
1367 LLVM_YAML_IS_SEQUENCE_VECTOR(uint16_t)
1368 TEST(YAMLIO, TestReadBuiltInTypesUint16Error) {
1369   std::vector<uint16_t> seq;
1370   Input yin("---\n"
1371             "- 65535\n"
1372             "- 0\n"
1373             "- 66000\n"
1374             "...\n",
1375             /*Ctxt=*/nullptr,
1376             suppressErrorMessages);
1377   yin >> seq;
1378
1379   EXPECT_TRUE(!!yin.error());
1380 }
1381
1382
1383 //
1384 // Test error handling reading built-in uint32_t type
1385 //
1386 LLVM_YAML_IS_SEQUENCE_VECTOR(uint32_t)
1387 TEST(YAMLIO, TestReadBuiltInTypesUint32Error) {
1388   std::vector<uint32_t> seq;
1389   Input yin("---\n"
1390             "- 4000000000\n"
1391             "- 0\n"
1392             "- 5000000000\n"
1393             "...\n",
1394             /*Ctxt=*/nullptr,
1395             suppressErrorMessages);
1396   yin >> seq;
1397
1398   EXPECT_TRUE(!!yin.error());
1399 }
1400
1401
1402 //
1403 // Test error handling reading built-in uint64_t type
1404 //
1405 LLVM_YAML_IS_SEQUENCE_VECTOR(uint64_t)
1406 TEST(YAMLIO, TestReadBuiltInTypesUint64Error) {
1407   std::vector<uint64_t> seq;
1408   Input yin("---\n"
1409             "- 18446744073709551615\n"
1410             "- 0\n"
1411             "- 19446744073709551615\n"
1412             "...\n",
1413             /*Ctxt=*/nullptr,
1414             suppressErrorMessages);
1415   yin >> seq;
1416
1417   EXPECT_TRUE(!!yin.error());
1418 }
1419
1420
1421 //
1422 // Test error handling reading built-in int8_t type
1423 //
1424 LLVM_YAML_IS_SEQUENCE_VECTOR(int8_t)
1425 TEST(YAMLIO, TestReadBuiltInTypesint8OverError) {
1426   std::vector<int8_t> seq;
1427   Input yin("---\n"
1428             "- -128\n"
1429             "- 0\n"
1430             "- 127\n"
1431             "- 128\n"
1432            "...\n",
1433             /*Ctxt=*/nullptr,
1434             suppressErrorMessages);
1435   yin >> seq;
1436
1437   EXPECT_TRUE(!!yin.error());
1438 }
1439
1440 //
1441 // Test error handling reading built-in int8_t type
1442 //
1443 TEST(YAMLIO, TestReadBuiltInTypesint8UnderError) {
1444   std::vector<int8_t> seq;
1445   Input yin("---\n"
1446             "- -128\n"
1447             "- 0\n"
1448             "- 127\n"
1449             "- -129\n"
1450             "...\n",
1451             /*Ctxt=*/nullptr,
1452             suppressErrorMessages);
1453   yin >> seq;
1454
1455   EXPECT_TRUE(!!yin.error());
1456 }
1457
1458
1459 //
1460 // Test error handling reading built-in int16_t type
1461 //
1462 LLVM_YAML_IS_SEQUENCE_VECTOR(int16_t)
1463 TEST(YAMLIO, TestReadBuiltInTypesint16UnderError) {
1464   std::vector<int16_t> seq;
1465   Input yin("---\n"
1466             "- 32767\n"
1467             "- 0\n"
1468             "- -32768\n"
1469             "- -32769\n"
1470             "...\n",
1471             /*Ctxt=*/nullptr,
1472             suppressErrorMessages);
1473   yin >> seq;
1474
1475   EXPECT_TRUE(!!yin.error());
1476 }
1477
1478
1479 //
1480 // Test error handling reading built-in int16_t type
1481 //
1482 TEST(YAMLIO, TestReadBuiltInTypesint16OverError) {
1483   std::vector<int16_t> seq;
1484   Input yin("---\n"
1485             "- 32767\n"
1486             "- 0\n"
1487             "- -32768\n"
1488             "- 32768\n"
1489             "...\n",
1490             /*Ctxt=*/nullptr,
1491             suppressErrorMessages);
1492   yin >> seq;
1493
1494   EXPECT_TRUE(!!yin.error());
1495 }
1496
1497
1498 //
1499 // Test error handling reading built-in int32_t type
1500 //
1501 LLVM_YAML_IS_SEQUENCE_VECTOR(int32_t)
1502 TEST(YAMLIO, TestReadBuiltInTypesint32UnderError) {
1503   std::vector<int32_t> seq;
1504   Input yin("---\n"
1505             "- 2147483647\n"
1506             "- 0\n"
1507             "- -2147483648\n"
1508             "- -2147483649\n"
1509             "...\n",
1510             /*Ctxt=*/nullptr,
1511             suppressErrorMessages);
1512   yin >> seq;
1513
1514   EXPECT_TRUE(!!yin.error());
1515 }
1516
1517 //
1518 // Test error handling reading built-in int32_t type
1519 //
1520 TEST(YAMLIO, TestReadBuiltInTypesint32OverError) {
1521   std::vector<int32_t> seq;
1522   Input yin("---\n"
1523             "- 2147483647\n"
1524             "- 0\n"
1525             "- -2147483648\n"
1526             "- 2147483649\n"
1527             "...\n",
1528             /*Ctxt=*/nullptr,
1529             suppressErrorMessages);
1530   yin >> seq;
1531
1532   EXPECT_TRUE(!!yin.error());
1533 }
1534
1535
1536 //
1537 // Test error handling reading built-in int64_t type
1538 //
1539 LLVM_YAML_IS_SEQUENCE_VECTOR(int64_t)
1540 TEST(YAMLIO, TestReadBuiltInTypesint64UnderError) {
1541   std::vector<int64_t> seq;
1542   Input yin("---\n"
1543             "- -9223372036854775808\n"
1544             "- 0\n"
1545             "- 9223372036854775807\n"
1546             "- -9223372036854775809\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 int64_t type
1557 //
1558 TEST(YAMLIO, TestReadBuiltInTypesint64OverError) {
1559   std::vector<int64_t> seq;
1560   Input yin("---\n"
1561             "- -9223372036854775808\n"
1562             "- 0\n"
1563             "- 9223372036854775807\n"
1564             "- 9223372036854775809\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 float type
1575 //
1576 LLVM_YAML_IS_SEQUENCE_VECTOR(float)
1577 TEST(YAMLIO, TestReadBuiltInTypesFloatError) {
1578   std::vector<float> seq;
1579   Input yin("---\n"
1580             "- 0.0\n"
1581             "- 1000.1\n"
1582             "- -123.456\n"
1583             "- 1.2.3\n"
1584             "...\n",
1585             /*Ctxt=*/nullptr,
1586             suppressErrorMessages);
1587   yin >> seq;
1588
1589   EXPECT_TRUE(!!yin.error());
1590 }
1591
1592 //
1593 // Test error handling reading built-in float type
1594 //
1595 LLVM_YAML_IS_SEQUENCE_VECTOR(double)
1596 TEST(YAMLIO, TestReadBuiltInTypesDoubleError) {
1597   std::vector<double> seq;
1598   Input yin("---\n"
1599             "- 0.0\n"
1600             "- 1000.1\n"
1601             "- -123.456\n"
1602             "- 1.2.3\n"
1603             "...\n",
1604             /*Ctxt=*/nullptr,
1605             suppressErrorMessages);
1606   yin >> seq;
1607
1608   EXPECT_TRUE(!!yin.error());
1609 }
1610
1611 //
1612 // Test error handling reading built-in Hex8 type
1613 //
1614 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex8)
1615 TEST(YAMLIO, TestReadBuiltInTypesHex8Error) {
1616   std::vector<Hex8> seq;
1617   Input yin("---\n"
1618             "- 0x12\n"
1619             "- 0xFE\n"
1620             "- 0x123\n"
1621             "...\n",
1622             /*Ctxt=*/nullptr,
1623             suppressErrorMessages);
1624   yin >> seq;
1625
1626   EXPECT_TRUE(!!yin.error());
1627 }
1628
1629
1630 //
1631 // Test error handling reading built-in Hex16 type
1632 //
1633 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex16)
1634 TEST(YAMLIO, TestReadBuiltInTypesHex16Error) {
1635   std::vector<Hex16> seq;
1636   Input yin("---\n"
1637             "- 0x0012\n"
1638             "- 0xFEFF\n"
1639             "- 0x12345\n"
1640             "...\n",
1641             /*Ctxt=*/nullptr,
1642             suppressErrorMessages);
1643   yin >> seq;
1644
1645   EXPECT_TRUE(!!yin.error());
1646 }
1647
1648 //
1649 // Test error handling reading built-in Hex32 type
1650 //
1651 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex32)
1652 TEST(YAMLIO, TestReadBuiltInTypesHex32Error) {
1653   std::vector<Hex32> seq;
1654   Input yin("---\n"
1655             "- 0x0012\n"
1656             "- 0xFEFF0000\n"
1657             "- 0x1234556789\n"
1658             "...\n",
1659             /*Ctxt=*/nullptr,
1660             suppressErrorMessages);
1661   yin >> seq;
1662
1663   EXPECT_TRUE(!!yin.error());
1664 }
1665
1666 //
1667 // Test error handling reading built-in Hex64 type
1668 //
1669 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex64)
1670 TEST(YAMLIO, TestReadBuiltInTypesHex64Error) {
1671   std::vector<Hex64> seq;
1672   Input yin("---\n"
1673             "- 0x0012\n"
1674             "- 0xFFEEDDCCBBAA9988\n"
1675             "- 0x12345567890ABCDEF0\n"
1676             "...\n",
1677             /*Ctxt=*/nullptr,
1678             suppressErrorMessages);
1679   yin >> seq;
1680
1681   EXPECT_TRUE(!!yin.error());
1682 }
1683
1684 TEST(YAMLIO, TestMalformedMapFailsGracefully) {
1685   FooBar doc;
1686   {
1687     // We pass the suppressErrorMessages handler to handle the error
1688     // message generated in the constructor of Input.
1689     Input yin("{foo:3, bar: 5}", /*Ctxt=*/nullptr, suppressErrorMessages);
1690     yin >> doc;
1691     EXPECT_TRUE(!!yin.error());
1692   }
1693
1694   {
1695     Input yin("---\nfoo:3\nbar: 5\n...\n", /*Ctxt=*/nullptr, suppressErrorMessages);
1696     yin >> doc;
1697     EXPECT_TRUE(!!yin.error());
1698   }
1699 }
1700
1701 struct OptionalTest {
1702   std::vector<int> Numbers;
1703 };
1704
1705 struct OptionalTestSeq {
1706   std::vector<OptionalTest> Tests;
1707 };
1708
1709 LLVM_YAML_IS_SEQUENCE_VECTOR(OptionalTest)
1710 namespace llvm {
1711 namespace yaml {
1712   template <>
1713   struct MappingTraits<OptionalTest> {
1714     static void mapping(IO& IO, OptionalTest &OT) {
1715       IO.mapOptional("Numbers", OT.Numbers);
1716     }
1717   };
1718
1719   template <>
1720   struct MappingTraits<OptionalTestSeq> {
1721     static void mapping(IO &IO, OptionalTestSeq &OTS) {
1722       IO.mapOptional("Tests", OTS.Tests);
1723     }
1724   };
1725 }
1726 }
1727
1728 TEST(YAMLIO, SequenceElideTest) {
1729   // Test that writing out a purely optional structure with its fields set to
1730   // default followed by other data is properly read back in.
1731   OptionalTestSeq Seq;
1732   OptionalTest One, Two, Three, Four;
1733   int N[] = {1, 2, 3};
1734   Three.Numbers.assign(N, N + 3);
1735   Seq.Tests.push_back(One);
1736   Seq.Tests.push_back(Two);
1737   Seq.Tests.push_back(Three);
1738   Seq.Tests.push_back(Four);
1739
1740   std::string intermediate;
1741   {
1742     llvm::raw_string_ostream ostr(intermediate);
1743     Output yout(ostr);
1744     yout << Seq;
1745   }
1746
1747   Input yin(intermediate);
1748   OptionalTestSeq Seq2;
1749   yin >> Seq2;
1750
1751   EXPECT_FALSE(yin.error());
1752
1753   EXPECT_EQ(4UL, Seq2.Tests.size());
1754
1755   EXPECT_TRUE(Seq2.Tests[0].Numbers.empty());
1756   EXPECT_TRUE(Seq2.Tests[1].Numbers.empty());
1757
1758   EXPECT_EQ(1, Seq2.Tests[2].Numbers[0]);
1759   EXPECT_EQ(2, Seq2.Tests[2].Numbers[1]);
1760   EXPECT_EQ(3, Seq2.Tests[2].Numbers[2]);
1761
1762   EXPECT_TRUE(Seq2.Tests[3].Numbers.empty());
1763 }
1764
1765 TEST(YAMLIO, TestEmptyStringFailsForMapWithRequiredFields) {
1766   FooBar doc;
1767   Input yin("");
1768   yin >> doc;
1769   EXPECT_TRUE(!!yin.error());
1770 }
1771
1772 TEST(YAMLIO, TestEmptyStringSucceedsForMapWithOptionalFields) {
1773   OptionalTest doc;
1774   Input yin("");
1775   yin >> doc;
1776   EXPECT_FALSE(yin.error());
1777 }
1778
1779 TEST(YAMLIO, TestEmptyStringSucceedsForSequence) {
1780   std::vector<uint8_t> seq;
1781   Input yin("", /*Ctxt=*/nullptr, suppressErrorMessages);
1782   yin >> seq;
1783
1784   EXPECT_FALSE(yin.error());
1785   EXPECT_TRUE(seq.empty());
1786 }