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;
30 //===----------------------------------------------------------------------===//
32 //===----------------------------------------------------------------------===//
38 typedef std::vector<FooBar> FooBarSequence;
40 LLVM_YAML_IS_SEQUENCE_VECTOR(FooBar)
46 struct MappingTraits<FooBar> {
47 static void mapping(IO &io, FooBar& fb) {
48 io.mapRequired("foo", fb.foo);
49 io.mapRequired("bar", fb.bar);
57 // Test the reading of a yaml mapping
59 TEST(YAMLIO, TestMapRead) {
62 Input yin("---\nfoo: 3\nbar: 5\n...\n");
65 EXPECT_FALSE(yin.error());
66 EXPECT_EQ(doc.foo, 3);
67 EXPECT_EQ(doc.bar, 5);
71 Input yin("{foo: 3, bar: 5}");
74 EXPECT_FALSE(yin.error());
75 EXPECT_EQ(doc.foo, 3);
76 EXPECT_EQ(doc.bar, 5);
81 // Test the reading of a yaml sequence of mappings
83 TEST(YAMLIO, TestSequenceMapRead) {
85 Input yin("---\n - foo: 3\n bar: 5\n - foo: 7\n bar: 9\n...\n");
88 EXPECT_FALSE(yin.error());
89 EXPECT_EQ(seq.size(), 2UL);
90 FooBar& map1 = seq[0];
91 FooBar& map2 = seq[1];
92 EXPECT_EQ(map1.foo, 3);
93 EXPECT_EQ(map1.bar, 5);
94 EXPECT_EQ(map2.foo, 7);
95 EXPECT_EQ(map2.bar, 9);
100 // Test writing then reading back a sequence of mappings
102 TEST(YAMLIO, TestSequenceMapWriteAndRead) {
103 std::string intermediate;
112 seq.push_back(entry1);
113 seq.push_back(entry2);
115 llvm::raw_string_ostream ostr(intermediate);
121 Input yin(intermediate);
125 EXPECT_FALSE(yin.error());
126 EXPECT_EQ(seq2.size(), 2UL);
127 FooBar& map1 = seq2[0];
128 FooBar& map2 = seq2[1];
129 EXPECT_EQ(map1.foo, 10);
130 EXPECT_EQ(map1.bar, -3);
131 EXPECT_EQ(map2.foo, 257);
132 EXPECT_EQ(map2.bar, 0);
137 //===----------------------------------------------------------------------===//
138 // Test built-in types
139 //===----------------------------------------------------------------------===//
141 struct BuiltInTypes {
164 struct MappingTraits<BuiltInTypes> {
165 static void mapping(IO &io, BuiltInTypes& bt) {
166 io.mapRequired("str", bt.str);
167 io.mapRequired("stdstr", bt.stdstr);
168 io.mapRequired("u64", bt.u64);
169 io.mapRequired("u32", bt.u32);
170 io.mapRequired("u16", bt.u16);
171 io.mapRequired("u8", bt.u8);
172 io.mapRequired("b", bt.b);
173 io.mapRequired("s64", bt.s64);
174 io.mapRequired("s32", bt.s32);
175 io.mapRequired("s16", bt.s16);
176 io.mapRequired("s8", bt.s8);
177 io.mapRequired("f", bt.f);
178 io.mapRequired("d", bt.d);
179 io.mapRequired("h8", bt.h8);
180 io.mapRequired("h16", bt.h16);
181 io.mapRequired("h32", bt.h32);
182 io.mapRequired("h64", bt.h64);
190 // Test the reading of all built-in scalar conversions
192 TEST(YAMLIO, TestReadBuiltInTypes) {
196 "stdstr: hello where?\n"
211 "h64: 0xFEDCBA9876543210\n"
215 EXPECT_FALSE(yin.error());
216 EXPECT_TRUE(map.str.equals("hello there"));
217 EXPECT_TRUE(map.stdstr == "hello where?");
218 EXPECT_EQ(map.u64, 5000000000ULL);
219 EXPECT_EQ(map.u32, 4000000000U);
220 EXPECT_EQ(map.u16, 65000);
221 EXPECT_EQ(map.u8, 255);
222 EXPECT_EQ(map.b, false);
223 EXPECT_EQ(map.s64, -5000000000LL);
224 EXPECT_EQ(map.s32, -2000000000L);
225 EXPECT_EQ(map.s16, -32000);
226 EXPECT_EQ(map.s8, -127);
227 EXPECT_EQ(map.f, 137.125);
228 EXPECT_EQ(map.d, -2.8625);
229 EXPECT_EQ(map.h8, Hex8(255));
230 EXPECT_EQ(map.h16, Hex16(0x8765));
231 EXPECT_EQ(map.h32, Hex32(0xFEDCBA98));
232 EXPECT_EQ(map.h64, Hex64(0xFEDCBA9876543210LL));
237 // Test writing then reading back all built-in scalar types
239 TEST(YAMLIO, TestReadWriteBuiltInTypes) {
240 std::string intermediate;
244 map.stdstr = "three four";
245 map.u64 = 6000000000ULL;
246 map.u32 = 3000000000U;
250 map.s64 = -6000000000LL;
251 map.s32 = -2000000000;
258 map.h32 = 3000000000U;
259 map.h64 = 6000000000LL;
261 llvm::raw_string_ostream ostr(intermediate);
267 Input yin(intermediate);
271 EXPECT_FALSE(yin.error());
272 EXPECT_TRUE(map.str.equals("one two"));
273 EXPECT_TRUE(map.stdstr == "three four");
274 EXPECT_EQ(map.u64, 6000000000ULL);
275 EXPECT_EQ(map.u32, 3000000000U);
276 EXPECT_EQ(map.u16, 50000);
277 EXPECT_EQ(map.u8, 254);
278 EXPECT_EQ(map.b, true);
279 EXPECT_EQ(map.s64, -6000000000LL);
280 EXPECT_EQ(map.s32, -2000000000L);
281 EXPECT_EQ(map.s16, -32000);
282 EXPECT_EQ(map.s8, -128);
283 EXPECT_EQ(map.f, 3.25);
284 EXPECT_EQ(map.d, -2.8625);
285 EXPECT_EQ(map.h8, Hex8(254));
286 EXPECT_EQ(map.h16, Hex16(50000));
287 EXPECT_EQ(map.h32, Hex32(3000000000U));
288 EXPECT_EQ(map.h64, Hex64(6000000000LL));
293 llvm::StringRef str1;
294 llvm::StringRef str2;
295 llvm::StringRef str3;
296 llvm::StringRef str4;
297 llvm::StringRef str5;
308 struct MappingTraits<StringTypes> {
309 static void mapping(IO &io, StringTypes& st) {
310 io.mapRequired("str1", st.str1);
311 io.mapRequired("str2", st.str2);
312 io.mapRequired("str3", st.str3);
313 io.mapRequired("str4", st.str4);
314 io.mapRequired("str5", st.str5);
315 io.mapRequired("stdstr1", st.stdstr1);
316 io.mapRequired("stdstr2", st.stdstr2);
317 io.mapRequired("stdstr3", st.stdstr3);
318 io.mapRequired("stdstr4", st.stdstr4);
319 io.mapRequired("stdstr5", st.stdstr5);
325 TEST(YAMLIO, TestReadWriteStringTypes) {
326 std::string intermediate;
334 map.stdstr1 = "'eee";
335 map.stdstr2 = "\"fff";
336 map.stdstr3 = "`ggg";
337 map.stdstr4 = "@hhh";
340 llvm::raw_string_ostream ostr(intermediate);
345 llvm::StringRef flowOut(intermediate);
346 EXPECT_NE(llvm::StringRef::npos, flowOut.find("'''aaa"));
347 EXPECT_NE(llvm::StringRef::npos, flowOut.find("'\"bbb'"));
348 EXPECT_NE(llvm::StringRef::npos, flowOut.find("'`ccc'"));
349 EXPECT_NE(llvm::StringRef::npos, flowOut.find("'@ddd'"));
350 EXPECT_NE(llvm::StringRef::npos, flowOut.find("''\n"));
351 EXPECT_NE(std::string::npos, flowOut.find("'''eee"));
352 EXPECT_NE(std::string::npos, flowOut.find("'\"fff'"));
353 EXPECT_NE(std::string::npos, flowOut.find("'`ggg'"));
354 EXPECT_NE(std::string::npos, flowOut.find("'@hhh'"));
355 EXPECT_NE(std::string::npos, flowOut.find("''\n"));
358 Input yin(intermediate);
362 EXPECT_FALSE(yin.error());
363 EXPECT_TRUE(map.str1.equals("'aaa"));
364 EXPECT_TRUE(map.str2.equals("\"bbb"));
365 EXPECT_TRUE(map.str3.equals("`ccc"));
366 EXPECT_TRUE(map.str4.equals("@ddd"));
367 EXPECT_TRUE(map.str5.equals(""));
368 EXPECT_TRUE(map.stdstr1 == "'eee");
369 EXPECT_TRUE(map.stdstr2 == "\"fff");
370 EXPECT_TRUE(map.stdstr3 == "`ggg");
371 EXPECT_TRUE(map.stdstr4 == "@hhh");
372 EXPECT_TRUE(map.stdstr5 == "");
376 //===----------------------------------------------------------------------===//
377 // Test ScalarEnumerationTraits
378 //===----------------------------------------------------------------------===//
399 struct ScalarEnumerationTraits<Colors> {
400 static void enumeration(IO &io, Colors &value) {
401 io.enumCase(value, "red", cRed);
402 io.enumCase(value, "blue", cBlue);
403 io.enumCase(value, "green", cGreen);
404 io.enumCase(value, "yellow",cYellow);
408 struct MappingTraits<ColorMap> {
409 static void mapping(IO &io, ColorMap& c) {
410 io.mapRequired("c1", c.c1);
411 io.mapRequired("c2", c.c2);
412 io.mapRequired("c3", c.c3);
413 io.mapOptional("c4", c.c4, cBlue); // supplies default
414 io.mapOptional("c5", c.c5, cYellow); // supplies default
415 io.mapOptional("c6", c.c6, cRed); // supplies default
423 // Test reading enumerated scalars
425 TEST(YAMLIO, TestEnumRead) {
435 EXPECT_FALSE(yin.error());
436 EXPECT_EQ(cBlue, map.c1);
437 EXPECT_EQ(cRed, map.c2);
438 EXPECT_EQ(cGreen, map.c3);
439 EXPECT_EQ(cBlue, map.c4); // tests default
440 EXPECT_EQ(cYellow,map.c5); // tests overridden
441 EXPECT_EQ(cRed, map.c6); // tests default
446 //===----------------------------------------------------------------------===//
447 // Test ScalarBitSetTraits
448 //===----------------------------------------------------------------------===//
457 inline MyFlags operator|(MyFlags a, MyFlags b) {
458 return static_cast<MyFlags>(
459 static_cast<uint32_t>(a) | static_cast<uint32_t>(b));
473 struct ScalarBitSetTraits<MyFlags> {
474 static void bitset(IO &io, MyFlags &value) {
475 io.bitSetCase(value, "big", flagBig);
476 io.bitSetCase(value, "flat", flagFlat);
477 io.bitSetCase(value, "round", flagRound);
478 io.bitSetCase(value, "pointy",flagPointy);
482 struct MappingTraits<FlagsMap> {
483 static void mapping(IO &io, FlagsMap& c) {
484 io.mapRequired("f1", c.f1);
485 io.mapRequired("f2", c.f2);
486 io.mapRequired("f3", c.f3);
487 io.mapOptional("f4", c.f4, MyFlags(flagRound));
495 // Test reading flow sequence representing bit-mask values
497 TEST(YAMLIO, TestFlagsRead) {
501 "f2: [ round, flat ]\n"
506 EXPECT_FALSE(yin.error());
507 EXPECT_EQ(flagBig, map.f1);
508 EXPECT_EQ(flagRound|flagFlat, map.f2);
509 EXPECT_EQ(flagNone, map.f3); // check empty set
510 EXPECT_EQ(flagRound, map.f4); // check optional key
515 // Test writing then reading back bit-mask values
517 TEST(YAMLIO, TestReadWriteFlags) {
518 std::string intermediate;
522 map.f2 = flagRound | flagFlat;
526 llvm::raw_string_ostream ostr(intermediate);
532 Input yin(intermediate);
536 EXPECT_FALSE(yin.error());
537 EXPECT_EQ(flagBig, map2.f1);
538 EXPECT_EQ(flagRound|flagFlat, map2.f2);
539 EXPECT_EQ(flagNone, map2.f3);
540 //EXPECT_EQ(flagRound, map2.f4); // check optional key
546 //===----------------------------------------------------------------------===//
548 //===----------------------------------------------------------------------===//
550 struct MyCustomType {
555 struct MyCustomTypeMap {
565 struct MappingTraits<MyCustomTypeMap> {
566 static void mapping(IO &io, MyCustomTypeMap& s) {
567 io.mapRequired("f1", s.f1);
568 io.mapRequired("f2", s.f2);
569 io.mapRequired("f3", s.f3);
572 // MyCustomType is formatted as a yaml scalar. A value of
573 // {length=3, width=4} would be represented in yaml as "3 by 4".
575 struct ScalarTraits<MyCustomType> {
576 static void output(const MyCustomType &value, void* ctxt, llvm::raw_ostream &out) {
577 out << llvm::format("%d by %d", value.length, value.width);
579 static StringRef input(StringRef scalar, void* ctxt, MyCustomType &value) {
580 size_t byStart = scalar.find("by");
581 if ( byStart != StringRef::npos ) {
582 StringRef lenStr = scalar.slice(0, byStart);
583 lenStr = lenStr.rtrim();
584 if ( lenStr.getAsInteger(0, value.length) ) {
585 return "malformed length";
587 StringRef widthStr = scalar.drop_front(byStart+2);
588 widthStr = widthStr.ltrim();
589 if ( widthStr.getAsInteger(0, value.width) ) {
590 return "malformed width";
595 return "malformed by";
604 // Test writing then reading back custom values
606 TEST(YAMLIO, TestReadWriteMyCustomType) {
607 std::string intermediate;
616 llvm::raw_string_ostream ostr(intermediate);
622 Input yin(intermediate);
623 MyCustomTypeMap map2;
626 EXPECT_FALSE(yin.error());
627 EXPECT_EQ(1, map2.f1.length);
628 EXPECT_EQ(4, map2.f1.width);
629 EXPECT_EQ(100, map2.f2.length);
630 EXPECT_EQ(400, map2.f2.width);
631 EXPECT_EQ(10, map2.f3);
636 //===----------------------------------------------------------------------===//
637 // Test flow sequences
638 //===----------------------------------------------------------------------===//
640 LLVM_YAML_STRONG_TYPEDEF(int, MyNumber)
641 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(MyNumber)
642 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::StringRef)
647 struct ScalarTraits<MyNumber> {
648 static void output(const MyNumber &value, void *, llvm::raw_ostream &out) {
652 static StringRef input(StringRef scalar, void *, MyNumber &value) {
654 if ( getAsSignedInteger(scalar, 0, n) )
655 return "invalid number";
663 struct NameAndNumbers {
664 llvm::StringRef name;
665 std::vector<llvm::StringRef> strings;
666 std::vector<MyNumber> single;
667 std::vector<MyNumber> numbers;
673 struct MappingTraits<NameAndNumbers> {
674 static void mapping(IO &io, NameAndNumbers& nn) {
675 io.mapRequired("name", nn.name);
676 io.mapRequired("strings", nn.strings);
677 io.mapRequired("single", nn.single);
678 io.mapRequired("numbers", nn.numbers);
686 // Test writing then reading back custom values
688 TEST(YAMLIO, TestReadWriteMyFlowSequence) {
689 std::string intermediate;
693 map.strings.push_back(llvm::StringRef("one"));
694 map.strings.push_back(llvm::StringRef("two"));
695 map.single.push_back(1);
696 map.numbers.push_back(10);
697 map.numbers.push_back(-30);
698 map.numbers.push_back(1024);
700 llvm::raw_string_ostream ostr(intermediate);
704 // Verify sequences were written in flow style
706 llvm::StringRef flowOut(intermediate);
707 EXPECT_NE(llvm::StringRef::npos, flowOut.find("one, two"));
708 EXPECT_NE(llvm::StringRef::npos, flowOut.find("10, -30, 1024"));
712 Input yin(intermediate);
716 EXPECT_FALSE(yin.error());
717 EXPECT_TRUE(map2.name.equals("hello"));
718 EXPECT_EQ(map2.strings.size(), 2UL);
719 EXPECT_TRUE(map2.strings[0].equals("one"));
720 EXPECT_TRUE(map2.strings[1].equals("two"));
721 EXPECT_EQ(map2.single.size(), 1UL);
722 EXPECT_EQ(1, map2.single[0]);
723 EXPECT_EQ(map2.numbers.size(), 3UL);
724 EXPECT_EQ(10, map2.numbers[0]);
725 EXPECT_EQ(-30, map2.numbers[1]);
726 EXPECT_EQ(1024, map2.numbers[2]);
731 //===----------------------------------------------------------------------===//
732 // Test normalizing/denormalizing
733 //===----------------------------------------------------------------------===//
735 LLVM_YAML_STRONG_TYPEDEF(uint32_t, TotalSeconds)
737 typedef std::vector<TotalSeconds> SecondsSequence;
739 LLVM_YAML_IS_SEQUENCE_VECTOR(TotalSeconds)
745 struct MappingTraits<TotalSeconds> {
747 class NormalizedSeconds {
749 NormalizedSeconds(IO &io)
750 : hours(0), minutes(0), seconds(0) {
752 NormalizedSeconds(IO &, TotalSeconds &secs)
754 minutes((secs - (hours*3600))/60),
757 TotalSeconds denormalize(IO &) {
758 return TotalSeconds(hours*3600 + minutes*60 + seconds);
766 static void mapping(IO &io, TotalSeconds &secs) {
767 MappingNormalization<NormalizedSeconds, TotalSeconds> keys(io, secs);
769 io.mapOptional("hours", keys->hours, (uint32_t)0);
770 io.mapOptional("minutes", keys->minutes, (uint8_t)0);
771 io.mapRequired("seconds", keys->seconds);
779 // Test the reading of a yaml sequence of mappings
781 TEST(YAMLIO, TestReadMySecondsSequence) {
783 Input yin("---\n - hours: 1\n seconds: 5\n - seconds: 59\n...\n");
786 EXPECT_FALSE(yin.error());
787 EXPECT_EQ(seq.size(), 2UL);
788 EXPECT_EQ(seq[0], 3605U);
789 EXPECT_EQ(seq[1], 59U);
794 // Test writing then reading back custom values
796 TEST(YAMLIO, TestReadWriteMySecondsSequence) {
797 std::string intermediate;
804 llvm::raw_string_ostream ostr(intermediate);
809 Input yin(intermediate);
810 SecondsSequence seq2;
813 EXPECT_FALSE(yin.error());
814 EXPECT_EQ(seq2.size(), 3UL);
815 EXPECT_EQ(seq2[0], 4000U);
816 EXPECT_EQ(seq2[1], 500U);
817 EXPECT_EQ(seq2[2], 59U);
822 //===----------------------------------------------------------------------===//
823 // Test dynamic typing
824 //===----------------------------------------------------------------------===//
843 struct KindAndFlags {
844 KindAndFlags() : kind(kindA), flags(0) { }
845 KindAndFlags(Kind k, uint32_t f) : kind(k), flags(f) { }
850 typedef std::vector<KindAndFlags> KindAndFlagsSequence;
852 LLVM_YAML_IS_SEQUENCE_VECTOR(KindAndFlags)
857 struct ScalarEnumerationTraits<AFlags> {
858 static void enumeration(IO &io, AFlags &value) {
859 io.enumCase(value, "a1", a1);
860 io.enumCase(value, "a2", a2);
861 io.enumCase(value, "a3", a3);
865 struct ScalarEnumerationTraits<BFlags> {
866 static void enumeration(IO &io, BFlags &value) {
867 io.enumCase(value, "b1", b1);
868 io.enumCase(value, "b2", b2);
869 io.enumCase(value, "b3", b3);
873 struct ScalarEnumerationTraits<Kind> {
874 static void enumeration(IO &io, Kind &value) {
875 io.enumCase(value, "A", kindA);
876 io.enumCase(value, "B", kindB);
880 struct MappingTraits<KindAndFlags> {
881 static void mapping(IO &io, KindAndFlags& kf) {
882 io.mapRequired("kind", kf.kind);
883 // Type of "flags" field varies depending on "kind" field.
884 // Use memcpy here to avoid breaking strict aliasing rules.
885 if (kf.kind == kindA) {
886 AFlags aflags = static_cast<AFlags>(kf.flags);
887 io.mapRequired("flags", aflags);
890 BFlags bflags = static_cast<BFlags>(kf.flags);
891 io.mapRequired("flags", bflags);
901 // Test the reading of a yaml sequence dynamic types
903 TEST(YAMLIO, TestReadKindAndFlagsSequence) {
904 KindAndFlagsSequence seq;
905 Input yin("---\n - kind: A\n flags: a2\n - kind: B\n flags: b1\n...\n");
908 EXPECT_FALSE(yin.error());
909 EXPECT_EQ(seq.size(), 2UL);
910 EXPECT_EQ(seq[0].kind, kindA);
911 EXPECT_EQ(seq[0].flags, (uint32_t)a2);
912 EXPECT_EQ(seq[1].kind, kindB);
913 EXPECT_EQ(seq[1].flags, (uint32_t)b1);
917 // Test writing then reading back dynamic types
919 TEST(YAMLIO, TestReadWriteKindAndFlagsSequence) {
920 std::string intermediate;
922 KindAndFlagsSequence seq;
923 seq.push_back(KindAndFlags(kindA,a1));
924 seq.push_back(KindAndFlags(kindB,b1));
925 seq.push_back(KindAndFlags(kindA,a2));
926 seq.push_back(KindAndFlags(kindB,b2));
927 seq.push_back(KindAndFlags(kindA,a3));
929 llvm::raw_string_ostream ostr(intermediate);
934 Input yin(intermediate);
935 KindAndFlagsSequence seq2;
938 EXPECT_FALSE(yin.error());
939 EXPECT_EQ(seq2.size(), 5UL);
940 EXPECT_EQ(seq2[0].kind, kindA);
941 EXPECT_EQ(seq2[0].flags, (uint32_t)a1);
942 EXPECT_EQ(seq2[1].kind, kindB);
943 EXPECT_EQ(seq2[1].flags, (uint32_t)b1);
944 EXPECT_EQ(seq2[2].kind, kindA);
945 EXPECT_EQ(seq2[2].flags, (uint32_t)a2);
946 EXPECT_EQ(seq2[3].kind, kindB);
947 EXPECT_EQ(seq2[3].flags, (uint32_t)b2);
948 EXPECT_EQ(seq2[4].kind, kindA);
949 EXPECT_EQ(seq2[4].flags, (uint32_t)a3);
954 //===----------------------------------------------------------------------===//
955 // Test document list
956 //===----------------------------------------------------------------------===//
962 typedef std::vector<FooBarMap> FooBarMapDocumentList;
964 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(FooBarMap)
970 struct MappingTraits<FooBarMap> {
971 static void mapping(IO &io, FooBarMap& fb) {
972 io.mapRequired("foo", fb.foo);
973 io.mapRequired("bar", fb.bar);
981 // Test the reading of a yaml mapping
983 TEST(YAMLIO, TestDocRead) {
985 Input yin("---\nfoo: 3\nbar: 5\n...\n");
988 EXPECT_FALSE(yin.error());
989 EXPECT_EQ(doc.foo, 3);
990 EXPECT_EQ(doc.bar,5);
996 // Test writing then reading back a sequence of mappings
998 TEST(YAMLIO, TestSequenceDocListWriteAndRead) {
999 std::string intermediate;
1007 std::vector<FooBarMap> docList;
1008 docList.push_back(doc1);
1009 docList.push_back(doc2);
1011 llvm::raw_string_ostream ostr(intermediate);
1018 Input yin(intermediate);
1019 std::vector<FooBarMap> docList2;
1022 EXPECT_FALSE(yin.error());
1023 EXPECT_EQ(docList2.size(), 2UL);
1024 FooBarMap& map1 = docList2[0];
1025 FooBarMap& map2 = docList2[1];
1026 EXPECT_EQ(map1.foo, 10);
1027 EXPECT_EQ(map1.bar, -3);
1028 EXPECT_EQ(map2.foo, 257);
1029 EXPECT_EQ(map2.bar, 0);
1033 //===----------------------------------------------------------------------===//
1034 // Test document tags
1035 //===----------------------------------------------------------------------===//
1038 MyDouble() : value(0.0) { }
1039 MyDouble(double x) : value(x) { }
1043 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(MyDouble)
1049 struct MappingTraits<MyDouble> {
1050 static void mapping(IO &io, MyDouble &d) {
1051 if (io.mapTag("!decimal", true)) {
1052 mappingDecimal(io, d);
1053 } else if (io.mapTag("!fraction")) {
1054 mappingFraction(io, d);
1057 static void mappingDecimal(IO &io, MyDouble &d) {
1058 io.mapRequired("value", d.value);
1060 static void mappingFraction(IO &io, MyDouble &d) {
1062 io.mapRequired("numerator", num);
1063 io.mapRequired("denominator", denom);
1064 // convert fraction to double
1065 d.value = num/denom;
1073 // Test the reading of two different tagged yaml documents.
1075 TEST(YAMLIO, TestTaggedDocuments) {
1076 std::vector<MyDouble> docList;
1077 Input yin("--- !decimal\nvalue: 3.0\n"
1078 "--- !fraction\nnumerator: 9.0\ndenominator: 2\n...\n");
1080 EXPECT_FALSE(yin.error());
1081 EXPECT_EQ(docList.size(), 2UL);
1082 EXPECT_EQ(docList[0].value, 3.0);
1083 EXPECT_EQ(docList[1].value, 4.5);
1089 // Test writing then reading back tagged documents
1091 TEST(YAMLIO, TestTaggedDocumentsWriteAndRead) {
1092 std::string intermediate;
1096 std::vector<MyDouble> docList;
1097 docList.push_back(a);
1098 docList.push_back(b);
1100 llvm::raw_string_ostream ostr(intermediate);
1106 Input yin(intermediate);
1107 std::vector<MyDouble> docList2;
1110 EXPECT_FALSE(yin.error());
1111 EXPECT_EQ(docList2.size(), 2UL);
1112 EXPECT_EQ(docList2[0].value, 10.25);
1113 EXPECT_EQ(docList2[1].value, -3.75);
1118 //===----------------------------------------------------------------------===//
1119 // Test dyn_cast<> on IO object
1120 //===----------------------------------------------------------------------===//
1125 typedef std::vector<DynCast> DynCastSequence;
1127 LLVM_YAML_IS_SEQUENCE_VECTOR(DynCast)
1132 struct MappingTraits<DynCast> {
1133 static void mapping(IO &io, DynCast& info) {
1134 // Change 10 to 13 when writing yaml.
1135 if (Output *output = dyn_cast<Output>(&io)) {
1137 if (info.value == 10)
1140 io.mapRequired("value", info.value);
1141 // Change 20 to 23 when parsing yaml.
1142 if (Input *input = dyn_cast<Input>(&io)) {
1144 if (info.value == 20)
1153 // Test writing then reading back a sequence of mappings
1155 TEST(YAMLIO, TestDynCast) {
1156 std::string intermediate;
1164 DynCastSequence seq;
1165 seq.push_back(entry1);
1166 seq.push_back(entry2);
1167 seq.push_back(entry3);
1169 llvm::raw_string_ostream ostr(intermediate);
1175 Input yin(intermediate);
1176 DynCastSequence seq2;
1179 EXPECT_FALSE(yin.error());
1180 EXPECT_EQ(seq2.size(), 3UL);
1181 EXPECT_EQ(seq2[0].value, 13); // Verify changed to 13.
1182 EXPECT_EQ(seq2[1].value, 23); // Verify changed to 23.
1183 EXPECT_EQ(seq2[2].value, 30); // Verify stays same.
1189 //===----------------------------------------------------------------------===//
1190 // Test error handling
1191 //===----------------------------------------------------------------------===//
1195 static void suppressErrorMessages(const llvm::SMDiagnostic &, void *) {
1200 // Test error handling of unknown enumerated scalar
1202 TEST(YAMLIO, TestColorsReadError) {
1210 suppressErrorMessages);
1212 EXPECT_TRUE(yin.error());
1217 // Test error handling of flow sequence with unknown value
1219 TEST(YAMLIO, TestFlagsReadError) {
1223 "f2: [ round, hollow ]\n"
1227 suppressErrorMessages);
1230 EXPECT_TRUE(yin.error());
1235 // Test error handling reading built-in uint8_t type
1237 LLVM_YAML_IS_SEQUENCE_VECTOR(uint8_t)
1238 TEST(YAMLIO, TestReadBuiltInTypesUint8Error) {
1239 std::vector<uint8_t> seq;
1246 suppressErrorMessages);
1249 EXPECT_TRUE(yin.error());
1254 // Test error handling reading built-in uint16_t type
1256 LLVM_YAML_IS_SEQUENCE_VECTOR(uint16_t)
1257 TEST(YAMLIO, TestReadBuiltInTypesUint16Error) {
1258 std::vector<uint16_t> seq;
1265 suppressErrorMessages);
1268 EXPECT_TRUE(yin.error());
1273 // Test error handling reading built-in uint32_t type
1275 LLVM_YAML_IS_SEQUENCE_VECTOR(uint32_t)
1276 TEST(YAMLIO, TestReadBuiltInTypesUint32Error) {
1277 std::vector<uint32_t> seq;
1284 suppressErrorMessages);
1287 EXPECT_TRUE(yin.error());
1292 // Test error handling reading built-in uint64_t type
1294 LLVM_YAML_IS_SEQUENCE_VECTOR(uint64_t)
1295 TEST(YAMLIO, TestReadBuiltInTypesUint64Error) {
1296 std::vector<uint64_t> seq;
1298 "- 18446744073709551615\n"
1300 "- 19446744073709551615\n"
1303 suppressErrorMessages);
1306 EXPECT_TRUE(yin.error());
1311 // Test error handling reading built-in int8_t type
1313 LLVM_YAML_IS_SEQUENCE_VECTOR(int8_t)
1314 TEST(YAMLIO, TestReadBuiltInTypesint8OverError) {
1315 std::vector<int8_t> seq;
1323 suppressErrorMessages);
1326 EXPECT_TRUE(yin.error());
1330 // Test error handling reading built-in int8_t type
1332 TEST(YAMLIO, TestReadBuiltInTypesint8UnderError) {
1333 std::vector<int8_t> seq;
1341 suppressErrorMessages);
1344 EXPECT_TRUE(yin.error());
1349 // Test error handling reading built-in int16_t type
1351 LLVM_YAML_IS_SEQUENCE_VECTOR(int16_t)
1352 TEST(YAMLIO, TestReadBuiltInTypesint16UnderError) {
1353 std::vector<int16_t> seq;
1361 suppressErrorMessages);
1364 EXPECT_TRUE(yin.error());
1369 // Test error handling reading built-in int16_t type
1371 TEST(YAMLIO, TestReadBuiltInTypesint16OverError) {
1372 std::vector<int16_t> seq;
1380 suppressErrorMessages);
1383 EXPECT_TRUE(yin.error());
1388 // Test error handling reading built-in int32_t type
1390 LLVM_YAML_IS_SEQUENCE_VECTOR(int32_t)
1391 TEST(YAMLIO, TestReadBuiltInTypesint32UnderError) {
1392 std::vector<int32_t> seq;
1400 suppressErrorMessages);
1403 EXPECT_TRUE(yin.error());
1407 // Test error handling reading built-in int32_t type
1409 TEST(YAMLIO, TestReadBuiltInTypesint32OverError) {
1410 std::vector<int32_t> seq;
1418 suppressErrorMessages);
1421 EXPECT_TRUE(yin.error());
1426 // Test error handling reading built-in int64_t type
1428 LLVM_YAML_IS_SEQUENCE_VECTOR(int64_t)
1429 TEST(YAMLIO, TestReadBuiltInTypesint64UnderError) {
1430 std::vector<int64_t> seq;
1432 "- -9223372036854775808\n"
1434 "- 9223372036854775807\n"
1435 "- -9223372036854775809\n"
1438 suppressErrorMessages);
1441 EXPECT_TRUE(yin.error());
1445 // Test error handling reading built-in int64_t type
1447 TEST(YAMLIO, TestReadBuiltInTypesint64OverError) {
1448 std::vector<int64_t> seq;
1450 "- -9223372036854775808\n"
1452 "- 9223372036854775807\n"
1453 "- 9223372036854775809\n"
1456 suppressErrorMessages);
1459 EXPECT_TRUE(yin.error());
1463 // Test error handling reading built-in float type
1465 LLVM_YAML_IS_SEQUENCE_VECTOR(float)
1466 TEST(YAMLIO, TestReadBuiltInTypesFloatError) {
1467 std::vector<float> seq;
1475 suppressErrorMessages);
1478 EXPECT_TRUE(yin.error());
1482 // Test error handling reading built-in float type
1484 LLVM_YAML_IS_SEQUENCE_VECTOR(double)
1485 TEST(YAMLIO, TestReadBuiltInTypesDoubleError) {
1486 std::vector<double> seq;
1494 suppressErrorMessages);
1497 EXPECT_TRUE(yin.error());
1501 // Test error handling reading built-in Hex8 type
1503 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex8)
1504 TEST(YAMLIO, TestReadBuiltInTypesHex8Error) {
1505 std::vector<Hex8> seq;
1512 suppressErrorMessages);
1515 EXPECT_TRUE(yin.error());
1520 // Test error handling reading built-in Hex16 type
1522 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex16)
1523 TEST(YAMLIO, TestReadBuiltInTypesHex16Error) {
1524 std::vector<Hex16> seq;
1531 suppressErrorMessages);
1534 EXPECT_TRUE(yin.error());
1538 // Test error handling reading built-in Hex32 type
1540 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex32)
1541 TEST(YAMLIO, TestReadBuiltInTypesHex32Error) {
1542 std::vector<Hex32> seq;
1549 suppressErrorMessages);
1552 EXPECT_TRUE(yin.error());
1556 // Test error handling reading built-in Hex64 type
1558 LLVM_YAML_IS_SEQUENCE_VECTOR(Hex64)
1559 TEST(YAMLIO, TestReadBuiltInTypesHex64Error) {
1560 std::vector<Hex64> seq;
1563 "- 0xFFEEDDCCBBAA9988\n"
1564 "- 0x12345567890ABCDEF0\n"
1567 suppressErrorMessages);
1570 EXPECT_TRUE(yin.error());
1573 TEST(YAMLIO, TestMalformedMapFailsGracefully) {
1576 // We pass the suppressErrorMessages handler to handle the error
1577 // message generated in the constructor of Input.
1578 Input yin("{foo:3, bar: 5}", /*Ctxt=*/NULL, suppressErrorMessages);
1580 EXPECT_TRUE(yin.error());
1584 Input yin("---\nfoo:3\nbar: 5\n...\n", /*Ctxt=*/NULL, suppressErrorMessages);
1586 EXPECT_TRUE(yin.error());
1590 struct OptionalTest {
1591 std::vector<int> Numbers;
1594 struct OptionalTestSeq {
1595 std::vector<OptionalTest> Tests;
1598 LLVM_YAML_IS_SEQUENCE_VECTOR(OptionalTest)
1602 struct MappingTraits<OptionalTest> {
1603 static void mapping(IO& IO, OptionalTest &OT) {
1604 IO.mapOptional("Numbers", OT.Numbers);
1609 struct MappingTraits<OptionalTestSeq> {
1610 static void mapping(IO &IO, OptionalTestSeq &OTS) {
1611 IO.mapOptional("Tests", OTS.Tests);
1617 TEST(YAMLIO, SequenceElideTest) {
1618 // Test that writing out a purely optional structure with its fields set to
1619 // default followed by other data is properly read back in.
1620 OptionalTestSeq Seq;
1621 OptionalTest One, Two, Three, Four;
1622 int N[] = {1, 2, 3};
1623 Three.Numbers.assign(N, N + 3);
1624 Seq.Tests.push_back(One);
1625 Seq.Tests.push_back(Two);
1626 Seq.Tests.push_back(Three);
1627 Seq.Tests.push_back(Four);
1629 std::string intermediate;
1631 llvm::raw_string_ostream ostr(intermediate);
1636 Input yin(intermediate);
1637 OptionalTestSeq Seq2;
1640 EXPECT_FALSE(yin.error());
1642 EXPECT_EQ(4UL, Seq2.Tests.size());
1644 EXPECT_TRUE(Seq2.Tests[0].Numbers.empty());
1645 EXPECT_TRUE(Seq2.Tests[1].Numbers.empty());
1647 EXPECT_EQ(1, Seq2.Tests[2].Numbers[0]);
1648 EXPECT_EQ(2, Seq2.Tests[2].Numbers[1]);
1649 EXPECT_EQ(3, Seq2.Tests[2].Numbers[2]);
1651 EXPECT_TRUE(Seq2.Tests[3].Numbers.empty());
1654 TEST(YAMLIO, TestEmptyStringFailsForMapWithRequiredFields) {
1658 EXPECT_TRUE(yin.error());
1661 TEST(YAMLIO, TestEmptyStringSucceedsForMapWithOptionalFields) {
1665 EXPECT_FALSE(yin.error());
1668 TEST(YAMLIO, TestEmptyStringSucceedsForSequence) {
1669 std::vector<uint8_t> seq;
1670 Input yin("", /*Ctxt=*/NULL, suppressErrorMessages);
1673 EXPECT_FALSE(yin.error());
1674 EXPECT_TRUE(seq.empty());