1 //===- unittest/Support/YAMLIOTest.cpp ------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/ADT/SmallString.h"
11 #include "llvm/ADT/Twine.h"
12 #include "llvm/Support/Casting.h"
13 #include "llvm/Support/Format.h"
14 #include "llvm/Support/YAMLTraits.h"
15 #include "gtest/gtest.h"
18 using llvm::yaml::Input;
19 using llvm::yaml::Output;
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;
32 static void suppressErrorMessages(const llvm::SMDiagnostic &, void *) {
37 //===----------------------------------------------------------------------===//
39 //===----------------------------------------------------------------------===//
45 typedef std::vector<FooBar> FooBarSequence;
47 LLVM_YAML_IS_SEQUENCE_VECTOR(FooBar)
49 struct FooBarContainer {
56 struct MappingTraits<FooBar> {
57 static void mapping(IO &io, FooBar& fb) {
58 io.mapRequired("foo", fb.foo);
59 io.mapRequired("bar", fb.bar);
63 template <> struct MappingTraits<FooBarContainer> {
64 static void mapping(IO &io, FooBarContainer &fb) {
65 io.mapRequired("fbs", fb.fbs);
73 // Test the reading of a yaml mapping
75 TEST(YAMLIO, TestMapRead) {
78 Input yin("---\nfoo: 3\nbar: 5\n...\n");
81 EXPECT_FALSE(yin.error());
82 EXPECT_EQ(doc.foo, 3);
83 EXPECT_EQ(doc.bar, 5);
87 Input yin("{foo: 3, bar: 5}");
90 EXPECT_FALSE(yin.error());
91 EXPECT_EQ(doc.foo, 3);
92 EXPECT_EQ(doc.bar, 5);
96 TEST(YAMLIO, TestMalformedMapRead) {
98 Input yin("{foo: 3; bar: 5}", nullptr, suppressErrorMessages);
100 EXPECT_TRUE(!!yin.error());
104 // Test the reading of a yaml sequence of mappings
106 TEST(YAMLIO, TestSequenceMapRead) {
108 Input yin("---\n - foo: 3\n bar: 5\n - foo: 7\n bar: 9\n...\n");
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);
122 // Test the reading of a map containing a yaml sequence of mappings
124 TEST(YAMLIO, TestContainerSequenceMapRead) {
126 FooBarContainer cont;
127 Input yin2("---\nfbs:\n - foo: 3\n bar: 5\n - foo: 7\n bar: 9\n...\n");
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);
139 FooBarContainer cont;
140 Input yin("---\nfbs:\n...\n");
142 // Okay: Empty node represents an empty array.
143 EXPECT_FALSE(yin.error());
144 EXPECT_EQ(cont.fbs.size(), 0UL);
148 FooBarContainer cont;
149 Input yin("---\nfbs: !!null null\n...\n");
151 // Okay: null represents an empty array.
152 EXPECT_FALSE(yin.error());
153 EXPECT_EQ(cont.fbs.size(), 0UL);
157 FooBarContainer cont;
158 Input yin("---\nfbs: ~\n...\n");
160 // Okay: null represents an empty array.
161 EXPECT_FALSE(yin.error());
162 EXPECT_EQ(cont.fbs.size(), 0UL);
166 FooBarContainer cont;
167 Input yin("---\nfbs: null\n...\n");
169 // Okay: null represents an empty array.
170 EXPECT_FALSE(yin.error());
171 EXPECT_EQ(cont.fbs.size(), 0UL);
176 // Test the reading of a map containing a malformed yaml sequence
178 TEST(YAMLIO, TestMalformedContainerSequenceMapRead) {
180 FooBarContainer cont;
181 Input yin("---\nfbs:\n foo: 3\n bar: 5\n...\n", nullptr,
182 suppressErrorMessages);
184 // Error: fbs is not a sequence.
185 EXPECT_TRUE(!!yin.error());
186 EXPECT_EQ(cont.fbs.size(), 0UL);
190 FooBarContainer cont;
191 Input yin("---\nfbs: 'scalar'\n...\n", nullptr, suppressErrorMessages);
193 // This should be an error.
194 EXPECT_TRUE(!!yin.error());
195 EXPECT_EQ(cont.fbs.size(), 0UL);
200 // Test writing then reading back a sequence of mappings
202 TEST(YAMLIO, TestSequenceMapWriteAndRead) {
203 std::string intermediate;
212 seq.push_back(entry1);
213 seq.push_back(entry2);
215 llvm::raw_string_ostream ostr(intermediate);
221 Input yin(intermediate);
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);
237 //===----------------------------------------------------------------------===//
238 // Test built-in types
239 //===----------------------------------------------------------------------===//
241 struct BuiltInTypes {
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);
290 // Test the reading of all built-in scalar conversions
292 TEST(YAMLIO, TestReadBuiltInTypes) {
296 "stdstr: hello where?\n"
311 "h64: 0xFEDCBA9876543210\n"
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));
337 // Test writing then reading back all built-in scalar types
339 TEST(YAMLIO, TestReadWriteBuiltInTypes) {
340 std::string intermediate;
344 map.stdstr = "three four";
345 map.u64 = 6000000000ULL;
346 map.u32 = 3000000000U;
350 map.s64 = -6000000000LL;
351 map.s32 = -2000000000;
358 map.h32 = 3000000000U;
359 map.h64 = 6000000000LL;
361 llvm::raw_string_ostream ostr(intermediate);
367 Input yin(intermediate);
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));
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;
413 std::string stdstr10;
414 std::string stdstr11;
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);
449 TEST(YAMLIO, TestReadWriteStringTypes) {
450 std::string intermediate;
458 map.str6 = "0000000004000000";
462 map.str10 = "0.2e20";
464 map.stdstr1 = "'eee";
465 map.stdstr2 = "\"fff";
466 map.stdstr3 = "`ggg";
467 map.stdstr4 = "@hhh";
469 map.stdstr6 = "0000000004000000";
470 map.stdstr7 = "true";
471 map.stdstr8 = "FALSE";
473 map.stdstr10 = "0.2e20";
474 map.stdstr11 = "0x30";
476 llvm::raw_string_ostream ostr(intermediate);
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"));
501 Input yin(intermediate);
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");
521 //===----------------------------------------------------------------------===//
522 // Test ScalarEnumerationTraits
523 //===----------------------------------------------------------------------===//
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);
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
568 // Test reading enumerated scalars
570 TEST(YAMLIO, TestEnumRead) {
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
591 //===----------------------------------------------------------------------===//
592 // Test ScalarBitSetTraits
593 //===----------------------------------------------------------------------===//
602 inline MyFlags operator|(MyFlags a, MyFlags b) {
603 return static_cast<MyFlags>(
604 static_cast<uint32_t>(a) | static_cast<uint32_t>(b));
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);
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));
640 // Test reading flow sequence representing bit-mask values
642 TEST(YAMLIO, TestFlagsRead) {
646 "f2: [ round, flat ]\n"
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
660 // Test writing then reading back bit-mask values
662 TEST(YAMLIO, TestReadWriteFlags) {
663 std::string intermediate;
667 map.f2 = flagRound | flagFlat;
671 llvm::raw_string_ostream ostr(intermediate);
677 Input yin(intermediate);
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
691 //===----------------------------------------------------------------------===//
693 //===----------------------------------------------------------------------===//
695 struct MyCustomType {
700 struct MyCustomTypeMap {
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);
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".
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);
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";
732 StringRef widthStr = scalar.drop_front(byStart+2);
733 widthStr = widthStr.ltrim();
734 if ( widthStr.getAsInteger(0, value.width) ) {
735 return "malformed width";
740 return "malformed by";
743 static bool mustQuote(StringRef) { return true; }
750 // Test writing then reading back custom values
752 TEST(YAMLIO, TestReadWriteMyCustomType) {
753 std::string intermediate;
762 llvm::raw_string_ostream ostr(intermediate);
768 Input yin(intermediate);
769 MyCustomTypeMap map2;
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);
782 //===----------------------------------------------------------------------===//
783 // Test BlockScalarTraits
784 //===----------------------------------------------------------------------===//
786 struct MultilineStringType {
790 struct MultilineStringTypeMap {
791 MultilineStringType name;
792 MultilineStringType description;
793 MultilineStringType ingredients;
794 MultilineStringType recipes;
795 MultilineStringType warningLabels;
796 MultilineStringType documentation;
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);
815 // MultilineStringType is formatted as a yaml block literal scalar. A value of
816 // "Hello\nWorld" would be represented in yaml as
821 struct BlockScalarTraits<MultilineStringType> {
822 static void output(const MultilineStringType &value, void *ctxt,
823 llvm::raw_ostream &out) {
826 static StringRef input(StringRef scalar, void *ctxt,
827 MultilineStringType &value) {
828 value.str = scalar.str();
835 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(MultilineStringType)
838 // Test writing then reading back custom values
840 TEST(YAMLIO, TestReadWriteMultilineStringType) {
841 std::string intermediate;
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";
852 llvm::raw_string_ostream ostr(intermediate);
857 Input yin(intermediate);
858 MultilineStringTypeMap map2;
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);
873 // Test writing then reading back custom values
875 TEST(YAMLIO, TestReadWriteBlockScalarDocuments) {
876 std::string intermediate;
878 std::vector<MultilineStringType> documents;
879 MultilineStringType doc;
880 doc.str = "Hello\nWorld";
881 documents.push_back(doc);
883 llvm::raw_string_ostream ostr(intermediate);
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("--- |"));
892 Input yin(intermediate);
893 std::vector<MultilineStringType> documents2;
896 EXPECT_FALSE(yin.error());
897 EXPECT_EQ(documents2.size(), size_t(1));
898 EXPECT_EQ(documents2[0].str, "Hello\nWorld\n");
902 TEST(YAMLIO, TestReadWriteBlockScalarValue) {
903 std::string intermediate;
905 MultilineStringType doc;
906 doc.str = "Just a block\nscalar doc";
908 llvm::raw_string_ostream ostr(intermediate);
913 Input yin(intermediate);
914 MultilineStringType doc;
917 EXPECT_FALSE(yin.error());
918 EXPECT_EQ(doc.str, "Just a block\nscalar doc\n");
922 //===----------------------------------------------------------------------===//
923 // Test flow sequences
924 //===----------------------------------------------------------------------===//
926 LLVM_YAML_STRONG_TYPEDEF(int, MyNumber)
927 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(MyNumber)
928 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::StringRef)
933 struct ScalarTraits<MyNumber> {
934 static void output(const MyNumber &value, void *, llvm::raw_ostream &out) {
938 static StringRef input(StringRef scalar, void *, MyNumber &value) {
940 if ( getAsSignedInteger(scalar, 0, n) )
941 return "invalid number";
946 static bool mustQuote(StringRef) { return false; }
951 struct NameAndNumbers {
952 llvm::StringRef name;
953 std::vector<llvm::StringRef> strings;
954 std::vector<MyNumber> single;
955 std::vector<MyNumber> numbers;
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);
972 typedef std::vector<MyNumber> MyNumberFlowSequence;
974 LLVM_YAML_IS_SEQUENCE_VECTOR(MyNumberFlowSequence)
976 struct NameAndNumbersFlow {
977 llvm::StringRef name;
978 std::vector<MyNumberFlowSequence> sequenceOfNumbers;
984 struct MappingTraits<NameAndNumbersFlow> {
985 static void mapping(IO &io, NameAndNumbersFlow& nn) {
986 io.mapRequired("name", nn.name);
987 io.mapRequired("sequenceOfNumbers", nn.sequenceOfNumbers);
994 // Test writing then reading back custom values
996 TEST(YAMLIO, TestReadWriteMyFlowSequence) {
997 std::string intermediate;
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);
1008 llvm::raw_string_ostream ostr(intermediate);
1012 // Verify sequences were written in flow style
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"));
1020 Input yin(intermediate);
1021 NameAndNumbers map2;
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]);
1040 // Test writing then reading back a sequence of flow sequences.
1042 TEST(YAMLIO, TestReadWriteSequenceOfMyFlowSequence) {
1043 std::string intermediate;
1045 NameAndNumbersFlow map;
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());
1053 llvm::raw_string_ostream ostr(intermediate);
1057 // Verify sequences were written in flow style
1058 // and that the parent sequence used '-'.
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("- [ ]"));
1067 Input yin(intermediate);
1068 NameAndNumbersFlow map2;
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());
1084 //===----------------------------------------------------------------------===//
1085 // Test normalizing/denormalizing
1086 //===----------------------------------------------------------------------===//
1088 LLVM_YAML_STRONG_TYPEDEF(uint32_t, TotalSeconds)
1090 typedef std::vector<TotalSeconds> SecondsSequence;
1092 LLVM_YAML_IS_SEQUENCE_VECTOR(TotalSeconds)
1098 struct MappingTraits<TotalSeconds> {
1100 class NormalizedSeconds {
1102 NormalizedSeconds(IO &io)
1103 : hours(0), minutes(0), seconds(0) {
1105 NormalizedSeconds(IO &, TotalSeconds &secs)
1107 minutes((secs - (hours*3600))/60),
1108 seconds(secs % 60) {
1110 TotalSeconds denormalize(IO &) {
1111 return TotalSeconds(hours*3600 + minutes*60 + seconds);
1119 static void mapping(IO &io, TotalSeconds &secs) {
1120 MappingNormalization<NormalizedSeconds, TotalSeconds> keys(io, secs);
1122 io.mapOptional("hours", keys->hours, (uint32_t)0);
1123 io.mapOptional("minutes", keys->minutes, (uint8_t)0);
1124 io.mapRequired("seconds", keys->seconds);
1132 // Test the reading of a yaml sequence of mappings
1134 TEST(YAMLIO, TestReadMySecondsSequence) {
1135 SecondsSequence seq;
1136 Input yin("---\n - hours: 1\n seconds: 5\n - seconds: 59\n...\n");
1139 EXPECT_FALSE(yin.error());
1140 EXPECT_EQ(seq.size(), 2UL);
1141 EXPECT_EQ(seq[0], 3605U);
1142 EXPECT_EQ(seq[1], 59U);
1147 // Test writing then reading back custom values
1149 TEST(YAMLIO, TestReadWriteMySecondsSequence) {
1150 std::string intermediate;
1152 SecondsSequence seq;
1153 seq.push_back(4000);
1157 llvm::raw_string_ostream ostr(intermediate);
1162 Input yin(intermediate);
1163 SecondsSequence seq2;
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);
1175 //===----------------------------------------------------------------------===//
1176 // Test dynamic typing
1177 //===----------------------------------------------------------------------===//
1196 struct KindAndFlags {
1197 KindAndFlags() : kind(kindA), flags(0) { }
1198 KindAndFlags(Kind k, uint32_t f) : kind(k), flags(f) { }
1203 typedef std::vector<KindAndFlags> KindAndFlagsSequence;
1205 LLVM_YAML_IS_SEQUENCE_VECTOR(KindAndFlags)
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);
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);
1226 struct ScalarEnumerationTraits<Kind> {
1227 static void enumeration(IO &io, Kind &value) {
1228 io.enumCase(value, "A", kindA);
1229 io.enumCase(value, "B", kindB);
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);
1243 BFlags bflags = static_cast<BFlags>(kf.flags);
1244 io.mapRequired("flags", bflags);
1254 // Test the reading of a yaml sequence dynamic types
1256 TEST(YAMLIO, TestReadKindAndFlagsSequence) {
1257 KindAndFlagsSequence seq;
1258 Input yin("---\n - kind: A\n flags: a2\n - kind: B\n flags: b1\n...\n");
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);
1270 // Test writing then reading back dynamic types
1272 TEST(YAMLIO, TestReadWriteKindAndFlagsSequence) {
1273 std::string intermediate;
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));
1282 llvm::raw_string_ostream ostr(intermediate);
1287 Input yin(intermediate);
1288 KindAndFlagsSequence seq2;
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);
1307 //===----------------------------------------------------------------------===//
1308 // Test document list
1309 //===----------------------------------------------------------------------===//
1315 typedef std::vector<FooBarMap> FooBarMapDocumentList;
1317 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(FooBarMap)
1323 struct MappingTraits<FooBarMap> {
1324 static void mapping(IO &io, FooBarMap& fb) {
1325 io.mapRequired("foo", fb.foo);
1326 io.mapRequired("bar", fb.bar);
1334 // Test the reading of a yaml mapping
1336 TEST(YAMLIO, TestDocRead) {
1338 Input yin("---\nfoo: 3\nbar: 5\n...\n");
1341 EXPECT_FALSE(yin.error());
1342 EXPECT_EQ(doc.foo, 3);
1343 EXPECT_EQ(doc.bar,5);
1349 // Test writing then reading back a sequence of mappings
1351 TEST(YAMLIO, TestSequenceDocListWriteAndRead) {
1352 std::string intermediate;
1360 std::vector<FooBarMap> docList;
1361 docList.push_back(doc1);
1362 docList.push_back(doc2);
1364 llvm::raw_string_ostream ostr(intermediate);
1371 Input yin(intermediate);
1372 std::vector<FooBarMap> docList2;
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);
1386 //===----------------------------------------------------------------------===//
1387 // Test document tags
1388 //===----------------------------------------------------------------------===//
1391 MyDouble() : value(0.0) { }
1392 MyDouble(double x) : value(x) { }
1396 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(MyDouble)
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);
1410 static void mappingDecimal(IO &io, MyDouble &d) {
1411 io.mapRequired("value", d.value);
1413 static void mappingFraction(IO &io, MyDouble &d) {
1415 io.mapRequired("numerator", num);
1416 io.mapRequired("denominator", denom);
1417 // convert fraction to double
1418 d.value = num/denom;
1426 // Test the reading of two different tagged yaml documents.
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");
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);
1442 // Test writing then reading back tagged documents
1444 TEST(YAMLIO, TestTaggedDocumentsWriteAndRead) {
1445 std::string intermediate;
1449 std::vector<MyDouble> docList;
1450 docList.push_back(a);
1451 docList.push_back(b);
1453 llvm::raw_string_ostream ostr(intermediate);
1459 Input yin(intermediate);
1460 std::vector<MyDouble> docList2;
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);
1471 //===----------------------------------------------------------------------===//
1472 // Test mapping validation
1473 //===----------------------------------------------------------------------===//
1475 struct MyValidation {
1479 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(MyValidation)
1484 struct MappingTraits<MyValidation> {
1485 static void mapping(IO &io, MyValidation &d) {
1486 io.mapRequired("value", d.value);
1488 static StringRef validate(IO &io, MyValidation &d) {
1490 return "negative value";
1499 // Test that validate() is called and complains about the negative value.
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);
1507 EXPECT_TRUE(!!yin.error());
1510 //===----------------------------------------------------------------------===//
1511 // Test flow mapping
1512 //===----------------------------------------------------------------------===//
1518 FlowFooBar() : foo(0), bar(0) {}
1519 FlowFooBar(int foo, int bar) : foo(foo), bar(bar) {}
1522 typedef std::vector<FlowFooBar> FlowFooBarSequence;
1524 LLVM_YAML_IS_SEQUENCE_VECTOR(FlowFooBar)
1526 struct FlowFooBarDoc {
1527 FlowFooBar attribute;
1528 FlowFooBarSequence seq;
1534 struct MappingTraits<FlowFooBar> {
1535 static void mapping(IO &io, FlowFooBar &fb) {
1536 io.mapRequired("foo", fb.foo);
1537 io.mapRequired("bar", fb.bar);
1540 static const bool flow = true;
1544 struct MappingTraits<FlowFooBarDoc> {
1545 static void mapping(IO &io, FlowFooBarDoc &fb) {
1546 io.mapRequired("attribute", fb.attribute);
1547 io.mapRequired("seq", fb.seq);
1554 // Test writing then reading back custom mappings
1556 TEST(YAMLIO, TestReadWriteMyFlowMapping) {
1557 std::string intermediate;
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));
1565 llvm::raw_string_ostream ostr(intermediate);
1569 // Verify that mappings were written in flow style
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 }"));
1579 Input yin(intermediate);
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);
1596 //===----------------------------------------------------------------------===//
1597 // Test error handling
1598 //===----------------------------------------------------------------------===//
1601 // Test error handling of unknown enumerated scalar
1603 TEST(YAMLIO, TestColorsReadError) {
1611 suppressErrorMessages);
1613 EXPECT_TRUE(!!yin.error());
1618 // Test error handling of flow sequence with unknown value
1620 TEST(YAMLIO, TestFlagsReadError) {
1624 "f2: [ round, hollow ]\n"
1628 suppressErrorMessages);
1631 EXPECT_TRUE(!!yin.error());
1636 // Test error handling reading built-in uint8_t type
1638 LLVM_YAML_IS_SEQUENCE_VECTOR(uint8_t)
1639 TEST(YAMLIO, TestReadBuiltInTypesUint8Error) {
1640 std::vector<uint8_t> seq;
1647 suppressErrorMessages);
1650 EXPECT_TRUE(!!yin.error());
1655 // Test error handling reading built-in uint16_t type
1657 LLVM_YAML_IS_SEQUENCE_VECTOR(uint16_t)
1658 TEST(YAMLIO, TestReadBuiltInTypesUint16Error) {
1659 std::vector<uint16_t> seq;
1666 suppressErrorMessages);
1669 EXPECT_TRUE(!!yin.error());
1674 // Test error handling reading built-in uint32_t type
1676 LLVM_YAML_IS_SEQUENCE_VECTOR(uint32_t)
1677 TEST(YAMLIO, TestReadBuiltInTypesUint32Error) {
1678 std::vector<uint32_t> seq;
1685 suppressErrorMessages);
1688 EXPECT_TRUE(!!yin.error());
1693 // Test error handling reading built-in uint64_t type
1695 LLVM_YAML_IS_SEQUENCE_VECTOR(uint64_t)
1696 TEST(YAMLIO, TestReadBuiltInTypesUint64Error) {
1697 std::vector<uint64_t> seq;
1699 "- 18446744073709551615\n"
1701 "- 19446744073709551615\n"
1704 suppressErrorMessages);
1707 EXPECT_TRUE(!!yin.error());
1712 // Test error handling reading built-in int8_t type
1714 LLVM_YAML_IS_SEQUENCE_VECTOR(int8_t)
1715 TEST(YAMLIO, TestReadBuiltInTypesint8OverError) {
1716 std::vector<int8_t> seq;
1724 suppressErrorMessages);
1727 EXPECT_TRUE(!!yin.error());
1731 // Test error handling reading built-in int8_t type
1733 TEST(YAMLIO, TestReadBuiltInTypesint8UnderError) {
1734 std::vector<int8_t> seq;
1742 suppressErrorMessages);
1745 EXPECT_TRUE(!!yin.error());
1750 // Test error handling reading built-in int16_t type
1752 LLVM_YAML_IS_SEQUENCE_VECTOR(int16_t)
1753 TEST(YAMLIO, TestReadBuiltInTypesint16UnderError) {
1754 std::vector<int16_t> seq;
1762 suppressErrorMessages);
1765 EXPECT_TRUE(!!yin.error());
1770 // Test error handling reading built-in int16_t type
1772 TEST(YAMLIO, TestReadBuiltInTypesint16OverError) {
1773 std::vector<int16_t> seq;
1781 suppressErrorMessages);
1784 EXPECT_TRUE(!!yin.error());
1789 // Test error handling reading built-in int32_t type
1791 LLVM_YAML_IS_SEQUENCE_VECTOR(int32_t)
1792 TEST(YAMLIO, TestReadBuiltInTypesint32UnderError) {
1793 std::vector<int32_t> seq;
1801 suppressErrorMessages);
1804 EXPECT_TRUE(!!yin.error());
1808 // Test error handling reading built-in int32_t type
1810 TEST(YAMLIO, TestReadBuiltInTypesint32OverError) {
1811 std::vector<int32_t> seq;
1819 suppressErrorMessages);
1822 EXPECT_TRUE(!!yin.error());
1827 // Test error handling reading built-in int64_t type
1829 LLVM_YAML_IS_SEQUENCE_VECTOR(int64_t)
1830 TEST(YAMLIO, TestReadBuiltInTypesint64UnderError) {
1831 std::vector<int64_t> seq;
1833 "- -9223372036854775808\n"
1835 "- 9223372036854775807\n"
1836 "- -9223372036854775809\n"
1839 suppressErrorMessages);
1842 EXPECT_TRUE(!!yin.error());
1846 // Test error handling reading built-in int64_t type
1848 TEST(YAMLIO, TestReadBuiltInTypesint64OverError) {
1849 std::vector<int64_t> seq;
1851 "- -9223372036854775808\n"
1853 "- 9223372036854775807\n"
1854 "- 9223372036854775809\n"
1857 suppressErrorMessages);
1860 EXPECT_TRUE(!!yin.error());
1864 // Test error handling reading built-in float type
1866 LLVM_YAML_IS_SEQUENCE_VECTOR(float)
1867 TEST(YAMLIO, TestReadBuiltInTypesFloatError) {
1868 std::vector<float> seq;
1876 suppressErrorMessages);
1879 EXPECT_TRUE(!!yin.error());
1883 // Test error handling reading built-in float type
1885 LLVM_YAML_IS_SEQUENCE_VECTOR(double)
1886 TEST(YAMLIO, TestReadBuiltInTypesDoubleError) {
1887 std::vector<double> seq;
1895 suppressErrorMessages);
1898 EXPECT_TRUE(!!yin.error());
1902 // Test error handling reading built-in Hex8 type
1904 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex8)
1905 TEST(YAMLIO, TestReadBuiltInTypesHex8Error) {
1906 std::vector<Hex8> seq;
1913 suppressErrorMessages);
1916 EXPECT_TRUE(!!yin.error());
1921 // Test error handling reading built-in Hex16 type
1923 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex16)
1924 TEST(YAMLIO, TestReadBuiltInTypesHex16Error) {
1925 std::vector<Hex16> seq;
1932 suppressErrorMessages);
1935 EXPECT_TRUE(!!yin.error());
1939 // Test error handling reading built-in Hex32 type
1941 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex32)
1942 TEST(YAMLIO, TestReadBuiltInTypesHex32Error) {
1943 std::vector<Hex32> seq;
1950 suppressErrorMessages);
1953 EXPECT_TRUE(!!yin.error());
1957 // Test error handling reading built-in Hex64 type
1959 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex64)
1960 TEST(YAMLIO, TestReadBuiltInTypesHex64Error) {
1961 std::vector<Hex64> seq;
1964 "- 0xFFEEDDCCBBAA9988\n"
1965 "- 0x12345567890ABCDEF0\n"
1968 suppressErrorMessages);
1971 EXPECT_TRUE(!!yin.error());
1974 TEST(YAMLIO, TestMalformedMapFailsGracefully) {
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);
1981 EXPECT_TRUE(!!yin.error());
1985 Input yin("---\nfoo:3\nbar: 5\n...\n", /*Ctxt=*/nullptr, suppressErrorMessages);
1987 EXPECT_TRUE(!!yin.error());
1991 struct OptionalTest {
1992 std::vector<int> Numbers;
1995 struct OptionalTestSeq {
1996 std::vector<OptionalTest> Tests;
1999 LLVM_YAML_IS_SEQUENCE_VECTOR(OptionalTest)
2003 struct MappingTraits<OptionalTest> {
2004 static void mapping(IO& IO, OptionalTest &OT) {
2005 IO.mapOptional("Numbers", OT.Numbers);
2010 struct MappingTraits<OptionalTestSeq> {
2011 static void mapping(IO &IO, OptionalTestSeq &OTS) {
2012 IO.mapOptional("Tests", OTS.Tests);
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);
2030 std::string intermediate;
2032 llvm::raw_string_ostream ostr(intermediate);
2037 Input yin(intermediate);
2038 OptionalTestSeq Seq2;
2041 EXPECT_FALSE(yin.error());
2043 EXPECT_EQ(4UL, Seq2.Tests.size());
2045 EXPECT_TRUE(Seq2.Tests[0].Numbers.empty());
2046 EXPECT_TRUE(Seq2.Tests[1].Numbers.empty());
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]);
2052 EXPECT_TRUE(Seq2.Tests[3].Numbers.empty());
2055 TEST(YAMLIO, TestEmptyStringFailsForMapWithRequiredFields) {
2059 EXPECT_TRUE(!!yin.error());
2062 TEST(YAMLIO, TestEmptyStringSucceedsForMapWithOptionalFields) {
2066 EXPECT_FALSE(yin.error());
2069 TEST(YAMLIO, TestEmptyStringSucceedsForSequence) {
2070 std::vector<uint8_t> seq;
2071 Input yin("", /*Ctxt=*/nullptr, suppressErrorMessages);
2074 EXPECT_FALSE(yin.error());
2075 EXPECT_TRUE(seq.empty());
2079 llvm::StringRef str1, str2, str3;
2080 FlowMap(llvm::StringRef str1, llvm::StringRef str2, llvm::StringRef str3)
2081 : str1(str1), str2(str2), str3(str3) {}
2085 llvm::StringRef str;
2086 FlowSeq(llvm::StringRef S) : str(S) {}
2087 FlowSeq() = default;
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);
2100 static const bool flow = true;
2104 struct ScalarTraits<FlowSeq> {
2105 static void output(const FlowSeq &value, void*, llvm::raw_ostream &out) {
2108 static StringRef input(StringRef scalar, void*, FlowSeq &value) {
2113 static bool mustQuote(StringRef S) { return false; }
2118 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FlowSeq)
2120 TEST(YAMLIO, TestWrapFlow) {
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");
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);
2138 "{ str1: This is str1, \n"
2139 " str2: This is str2, \n"
2140 " str3: This is str3 }\n"
2148 "[ This is str1, \n"
2155 // 25 will allow the second field to be output on the first line.
2156 Output yout(ostr, nullptr, 25);
2162 "{ str1: This is str1, str2: This is str2, \n"
2163 " str3: This is str3 }\n"
2171 "[ This is str1, This is str2, \n"
2177 // 0 means no wrapping.
2178 Output yout(ostr, nullptr, 0);
2184 "{ str1: This is str1, str2: This is str2, str3: This is str3 }\n"
2192 "[ This is str1, This is str2, This is str3 ]\n"