| #include "yaml-cpp/emitterstyle.h" |
| #include "yaml-cpp/eventhandler.h" |
| #include "yaml-cpp/yaml.h" // IWYU pragma: keep |
| #include "gtest/gtest.h" |
| |
| namespace YAML { |
| namespace { |
| |
| class NullEventHandler : public EventHandler { |
| virtual void OnDocumentStart(const Mark&) {} |
| virtual void OnDocumentEnd() {} |
| |
| virtual void OnNull(const Mark&, anchor_t) {} |
| virtual void OnAlias(const Mark&, anchor_t) {} |
| virtual void OnScalar(const Mark&, const std::string&, anchor_t, |
| const std::string&) {} |
| |
| virtual void OnSequenceStart(const Mark&, const std::string&, anchor_t, |
| EmitterStyle::value /* style */) {} |
| virtual void OnSequenceEnd() {} |
| |
| virtual void OnMapStart(const Mark&, const std::string&, anchor_t, |
| EmitterStyle::value /* style */) {} |
| virtual void OnMapEnd() {} |
| }; |
| |
| class EmitterTest : public ::testing::Test { |
| protected: |
| void ExpectEmit(const std::string& expected) { |
| EXPECT_EQ(expected, out.c_str()); |
| EXPECT_TRUE(out.good()) << "Emitter raised: " << out.GetLastError(); |
| if (expected == out.c_str()) { |
| std::stringstream stream(expected); |
| Parser parser; |
| NullEventHandler handler; |
| parser.HandleNextDocument(handler); |
| } |
| } |
| |
| Emitter out; |
| }; |
| |
| TEST_F(EmitterTest, SimpleScalar) { |
| out << "Hello, World!"; |
| |
| ExpectEmit("Hello, World!"); |
| } |
| |
| TEST_F(EmitterTest, SimpleQuotedScalar) { |
| Node n(Load("\"test\"")); |
| out << n; |
| ExpectEmit("test"); |
| } |
| |
| TEST_F(EmitterTest, DumpAndSize) { |
| Node n(Load("test")); |
| EXPECT_EQ("test", Dump(n)); |
| out << n; |
| EXPECT_EQ(4, out.size()); |
| } |
| |
| TEST_F(EmitterTest, NullScalar) { |
| Node n(Load("null")); |
| out << n; |
| ExpectEmit("~"); |
| } |
| |
| TEST_F(EmitterTest, AliasScalar) { |
| Node n(Load("[&a str, *a]")); |
| out << n; |
| ExpectEmit("[&1 str, *1]"); |
| } |
| |
| TEST_F(EmitterTest, StringFormat) { |
| out << BeginSeq; |
| out.SetStringFormat(SingleQuoted); |
| out << "string"; |
| out.SetStringFormat(DoubleQuoted); |
| out << "string"; |
| out.SetStringFormat(Literal); |
| out << "string"; |
| out << EndSeq; |
| |
| ExpectEmit("- 'string'\n- \"string\"\n- |\n string"); |
| } |
| |
| TEST_F(EmitterTest, IntBase) { |
| out << BeginSeq; |
| out.SetIntBase(Dec); |
| out << 1024; |
| out.SetIntBase(Hex); |
| out << 1024; |
| out.SetIntBase(Oct); |
| out << 1024; |
| out << EndSeq; |
| |
| ExpectEmit("- 1024\n- 0x400\n- 02000"); |
| } |
| |
| TEST_F(EmitterTest, NumberPrecision) { |
| out.SetFloatPrecision(3); |
| out.SetDoublePrecision(2); |
| out << BeginSeq; |
| out << 3.1425926f; |
| out << 53.5893; |
| out << 2384626.4338; |
| out << EndSeq; |
| |
| ExpectEmit("- 3.14\n- 54\n- 2.4e+06"); |
| } |
| |
| TEST_F(EmitterTest, SimpleSeq) { |
| out << BeginSeq; |
| out << "eggs"; |
| out << "bread"; |
| out << "milk"; |
| out << EndSeq; |
| |
| ExpectEmit("- eggs\n- bread\n- milk"); |
| } |
| |
| TEST_F(EmitterTest, SimpleFlowSeq) { |
| out << Flow; |
| out << BeginSeq; |
| out << "Larry"; |
| out << "Curly"; |
| out << "Moe"; |
| out << EndSeq; |
| |
| ExpectEmit("[Larry, Curly, Moe]"); |
| } |
| |
| TEST_F(EmitterTest, EmptyFlowSeq) { |
| out << Flow; |
| out << BeginSeq; |
| out << EndSeq; |
| |
| ExpectEmit("[]"); |
| } |
| |
| TEST_F(EmitterTest, EmptyBlockSeqWithBegunContent) { |
| out << BeginSeq; |
| out << BeginSeq << Comment("comment") << EndSeq; |
| out << BeginSeq << Newline << EndSeq; |
| out << EndSeq; |
| |
| ExpectEmit(R"(- |
| # comment |
| [] |
| - |
| |
| [])"); |
| } |
| |
| TEST_F(EmitterTest, EmptyBlockMapWithBegunContent) { |
| out << BeginSeq; |
| out << BeginMap << Comment("comment") << EndMap; |
| out << BeginMap << Newline << EndMap; |
| out << EndSeq; |
| |
| ExpectEmit(R"(- # comment |
| {} |
| - |
| {})"); |
| } |
| |
| TEST_F(EmitterTest, EmptyFlowSeqWithBegunContent) { |
| out << Flow; |
| out << BeginSeq; |
| out << BeginSeq << Comment("comment") << EndSeq; |
| out << BeginSeq << Newline << EndSeq; |
| out << EndSeq; |
| |
| ExpectEmit(R"([[ # comment |
| ], [ |
| ]])"); |
| } |
| |
| TEST_F(EmitterTest, EmptyFlowMapWithBegunContent) { |
| out << Flow; |
| out << BeginSeq; |
| out << BeginMap << Comment("comment") << EndMap; |
| out << BeginMap << Newline << EndMap; |
| out << EndSeq; |
| |
| ExpectEmit(R"([{ # comment |
| }, { |
| }])"); |
| } |
| |
| TEST_F(EmitterTest, NestedBlockSeq) { |
| out << BeginSeq; |
| out << "item 1"; |
| out << BeginSeq << "subitem 1" |
| << "subitem 2" << EndSeq; |
| out << EndSeq; |
| |
| ExpectEmit("- item 1\n-\n - subitem 1\n - subitem 2"); |
| } |
| |
| TEST_F(EmitterTest, NestedFlowSeq) { |
| out << BeginSeq; |
| out << "one"; |
| out << Flow << BeginSeq << "two" |
| << "three" << EndSeq; |
| out << EndSeq; |
| |
| ExpectEmit("- one\n- [two, three]"); |
| } |
| |
| TEST_F(EmitterTest, SimpleMap) { |
| out << BeginMap; |
| out << Key << "name"; |
| out << Value << "Ryan Braun"; |
| out << Key << "position"; |
| out << Value << "3B"; |
| out << EndMap; |
| |
| ExpectEmit("name: Ryan Braun\nposition: 3B"); |
| } |
| |
| TEST_F(EmitterTest, SimpleFlowMap) { |
| out << Flow; |
| out << BeginMap; |
| out << Key << "shape"; |
| out << Value << "square"; |
| out << Key << "color"; |
| out << Value << "blue"; |
| out << EndMap; |
| |
| ExpectEmit("{shape: square, color: blue}"); |
| } |
| |
| TEST_F(EmitterTest, MapAndList) { |
| out << BeginMap; |
| out << Key << "name"; |
| out << Value << "Barack Obama"; |
| out << Key << "children"; |
| out << Value << BeginSeq << "Sasha" |
| << "Malia" << EndSeq; |
| out << EndMap; |
| |
| ExpectEmit("name: Barack Obama\nchildren:\n - Sasha\n - Malia"); |
| } |
| |
| TEST_F(EmitterTest, ListAndMap) { |
| out << BeginSeq; |
| out << "item 1"; |
| out << BeginMap; |
| out << Key << "pens" << Value << 8; |
| out << Key << "pencils" << Value << 14; |
| out << EndMap; |
| out << "item 2"; |
| out << EndSeq; |
| |
| ExpectEmit("- item 1\n- pens: 8\n pencils: 14\n- item 2"); |
| } |
| |
| TEST_F(EmitterTest, NestedBlockMap) { |
| out << BeginMap; |
| out << Key << "name"; |
| out << Value << "Fred"; |
| out << Key << "grades"; |
| out << Value; |
| out << BeginMap; |
| out << Key << "algebra" << Value << "A"; |
| out << Key << "physics" << Value << "C+"; |
| out << Key << "literature" << Value << "B"; |
| out << EndMap; |
| out << EndMap; |
| |
| ExpectEmit( |
| "name: Fred\ngrades:\n algebra: A\n physics: C+\n literature: B"); |
| } |
| |
| TEST_F(EmitterTest, NestedFlowMap) { |
| out << Flow; |
| out << BeginMap; |
| out << Key << "name"; |
| out << Value << "Fred"; |
| out << Key << "grades"; |
| out << Value; |
| out << BeginMap; |
| out << Key << "algebra" << Value << "A"; |
| out << Key << "physics" << Value << "C+"; |
| out << Key << "literature" << Value << "B"; |
| out << EndMap; |
| out << EndMap; |
| |
| ExpectEmit("{name: Fred, grades: {algebra: A, physics: C+, literature: B}}"); |
| } |
| |
| TEST_F(EmitterTest, MapListMix) { |
| out << BeginMap; |
| out << Key << "name"; |
| out << Value << "Bob"; |
| out << Key << "position"; |
| out << Value; |
| out << Flow << BeginSeq << 2 << 4 << EndSeq; |
| out << Key << "invincible" << Value << OnOffBool << false; |
| out << EndMap; |
| |
| ExpectEmit("name: Bob\nposition: [2, 4]\ninvincible: off"); |
| } |
| |
| TEST_F(EmitterTest, SimpleLongKey) { |
| out << LongKey; |
| out << BeginMap; |
| out << Key << "height"; |
| out << Value << "5'9\""; |
| out << Key << "weight"; |
| out << Value << 145; |
| out << EndMap; |
| |
| ExpectEmit("? height\n: 5'9\"\n? weight\n: 145"); |
| } |
| |
| TEST_F(EmitterTest, SingleLongKey) { |
| const std::string shortKey(1024, 'a'); |
| const std::string longKey(1025, 'a'); |
| out << BeginMap; |
| out << Key << "age"; |
| out << Value << "24"; |
| out << LongKey << Key << "height"; |
| out << Value << "5'9\""; |
| out << Key << "weight"; |
| out << Value << 145; |
| out << Key << shortKey; |
| out << Value << "1"; |
| out << Key << longKey; |
| out << Value << "1"; |
| out << EndMap; |
| |
| ExpectEmit("age: 24\n? height\n: 5'9\"\nweight: 145\n" + shortKey + |
| ": 1\n? " + longKey + "\n: 1"); |
| } |
| |
| TEST_F(EmitterTest, ComplexLongKey) { |
| out << LongKey; |
| out << BeginMap; |
| out << Key << BeginSeq << 1 << 3 << EndSeq; |
| out << Value << "monster"; |
| out << Key << Flow << BeginSeq << 2 << 0 << EndSeq; |
| out << Value << "demon"; |
| out << EndMap; |
| |
| ExpectEmit("? - 1\n - 3\n: monster\n? [2, 0]\n: demon"); |
| } |
| |
| TEST_F(EmitterTest, AutoLongKey) { |
| out << BeginMap; |
| out << Key << BeginSeq << 1 << 3 << EndSeq; |
| out << Value << "monster"; |
| out << Key << Flow << BeginSeq << 2 << 0 << EndSeq; |
| out << Value << "demon"; |
| out << Key << "the origin"; |
| out << Value << "angel"; |
| out << EndMap; |
| |
| ExpectEmit("? - 1\n - 3\n: monster\n[2, 0]: demon\nthe origin: angel"); |
| } |
| |
| TEST_F(EmitterTest, ScalarFormat) { |
| out << BeginSeq; |
| out << "simple scalar"; |
| out << SingleQuoted << "explicit single-quoted scalar"; |
| out << DoubleQuoted << "explicit double-quoted scalar"; |
| out << "auto-detected\ndouble-quoted scalar"; |
| out << "a non-\"auto-detected\" double-quoted scalar"; |
| out << Literal |
| << "literal scalar\nthat may span\nmany, many\nlines " |
| "and have \"whatever\" crazy\tsymbols that we like"; |
| out << EndSeq; |
| |
| ExpectEmit( |
| "- simple scalar\n- 'explicit single-quoted scalar'\n- \"explicit " |
| "double-quoted scalar\"\n- \"auto-detected\\ndouble-quoted " |
| "scalar\"\n- a " |
| "non-\"auto-detected\" double-quoted scalar\n- |\n literal scalar\n " |
| " " |
| "that may span\n many, many\n lines and have \"whatever\" " |
| "crazy\tsymbols that we like"); |
| } |
| |
| TEST_F(EmitterTest, LiteralWithoutTrailingSpaces) { |
| out << YAML::BeginMap; |
| out << YAML::Key << "key"; |
| out << YAML::Value << YAML::Literal; |
| out << "expect that with two newlines\n\n" |
| "no spaces are emitted in the empty line"; |
| out << YAML::EndMap; |
| |
| ExpectEmit( |
| "key: |\n" |
| " expect that with two newlines\n\n" |
| " no spaces are emitted in the empty line"); |
| } |
| |
| TEST_F(EmitterTest, AutoLongKeyScalar) { |
| out << BeginMap; |
| out << Key << Literal << "multi-line\nscalar"; |
| out << Value << "and its value"; |
| out << EndMap; |
| |
| ExpectEmit("? |\n multi-line\n scalar\n: and its value"); |
| } |
| |
| TEST_F(EmitterTest, LongKeyFlowMap) { |
| out << Flow; |
| out << BeginMap; |
| out << Key << "simple key"; |
| out << Value << "and value"; |
| out << LongKey << Key << "long key"; |
| out << Value << "and its value"; |
| out << EndMap; |
| |
| ExpectEmit("{simple key: and value, ? long key: and its value}"); |
| } |
| |
| TEST_F(EmitterTest, BlockMapAsKey) { |
| out << BeginMap; |
| out << Key; |
| out << BeginMap; |
| out << Key << "key" << Value << "value"; |
| out << Key << "next key" << Value << "next value"; |
| out << EndMap; |
| out << Value; |
| out << "total value"; |
| out << EndMap; |
| |
| ExpectEmit("? key: value\n next key: next value\n: total value"); |
| } |
| |
| TEST_F(EmitterTest, TaggedBlockMapAsKey) { |
| out << BeginMap; |
| out << Key; |
| out << LocalTag("innerMap"); |
| out << BeginMap; |
| out << Key << "key" << Value << "value"; |
| out << EndMap; |
| out << Value; |
| out << "outerValue"; |
| out << EndMap; |
| |
| ExpectEmit(R"(? !innerMap |
| key: value |
| : outerValue)"); |
| } |
| |
| TEST_F(EmitterTest, TaggedBlockListAsKey) { |
| out << BeginMap; |
| out << Key; |
| out << LocalTag("innerList"); |
| out << BeginSeq; |
| out << "listItem"; |
| out << EndSeq; |
| out << Value; |
| out << "outerValue"; |
| out << EndMap; |
| |
| ExpectEmit(R"(? !innerList |
| - listItem |
| : outerValue)"); |
| } |
| |
| TEST_F(EmitterTest, AliasAndAnchor) { |
| out << BeginSeq; |
| out << Anchor("fred"); |
| out << BeginMap; |
| out << Key << "name" << Value << "Fred"; |
| out << Key << "age" << Value << 42; |
| out << EndMap; |
| out << Alias("fred"); |
| out << EndSeq; |
| |
| ExpectEmit("- &fred\n name: Fred\n age: 42\n- *fred"); |
| } |
| |
| TEST_F(EmitterTest, AliasOnKey) { |
| out << BeginSeq; |
| out << Anchor("name") << "Name"; |
| out << BeginMap; |
| out << Key << Alias("name") << Value << "Fred"; |
| out << EndMap; |
| out << Flow << BeginMap; |
| out << Key << Alias("name") << Value << "Mike"; |
| out << EndMap; |
| out << EndSeq; |
| ExpectEmit(R"(- &name Name |
| - *name : Fred |
| - {*name : Mike})"); |
| } |
| |
| TEST_F(EmitterTest, AliasAndAnchorWithNull) { |
| out << BeginSeq; |
| out << Anchor("fred") << Null; |
| out << Alias("fred"); |
| out << EndSeq; |
| |
| ExpectEmit("- &fred ~\n- *fred"); |
| } |
| |
| TEST_F(EmitterTest, AliasAndAnchorInFlow) { |
| out << Flow << BeginSeq; |
| out << Anchor("fred"); |
| out << BeginMap; |
| out << Key << "name" << Value << "Fred"; |
| out << Key << "age" << Value << 42; |
| out << EndMap; |
| out << Alias("fred"); |
| out << EndSeq; |
| |
| ExpectEmit("[&fred {name: Fred, age: 42}, *fred]"); |
| } |
| |
| TEST_F(EmitterTest, SimpleVerbatimTag) { |
| out << VerbatimTag("!foo") << "bar"; |
| |
| ExpectEmit("!<!foo> bar"); |
| } |
| |
| TEST_F(EmitterTest, VerbatimTagInBlockSeq) { |
| out << BeginSeq; |
| out << VerbatimTag("!foo") << "bar"; |
| out << "baz"; |
| out << EndSeq; |
| |
| ExpectEmit("- !<!foo> bar\n- baz"); |
| } |
| |
| TEST_F(EmitterTest, VerbatimTagInFlowSeq) { |
| out << Flow << BeginSeq; |
| out << VerbatimTag("!foo") << "bar"; |
| out << "baz"; |
| out << EndSeq; |
| |
| ExpectEmit("[!<!foo> bar, baz]"); |
| } |
| |
| TEST_F(EmitterTest, VerbatimTagInFlowSeqWithNull) { |
| out << Flow << BeginSeq; |
| out << VerbatimTag("!foo") << Null; |
| out << "baz"; |
| out << EndSeq; |
| |
| ExpectEmit("[!<!foo> ~, baz]"); |
| } |
| |
| TEST_F(EmitterTest, VerbatimTagInBlockMap) { |
| out << BeginMap; |
| out << Key << VerbatimTag("!foo") << "bar"; |
| out << Value << VerbatimTag("!waz") << "baz"; |
| out << EndMap; |
| |
| ExpectEmit("? !<!foo> bar\n: !<!waz> baz"); |
| } |
| |
| TEST_F(EmitterTest, VerbatimTagInFlowMap) { |
| out << Flow << BeginMap; |
| out << Key << VerbatimTag("!foo") << "bar"; |
| out << Value << "baz"; |
| out << EndMap; |
| |
| ExpectEmit("{!<!foo> bar: baz}"); |
| } |
| |
| TEST_F(EmitterTest, VerbatimTagInFlowMapWithNull) { |
| out << Flow << BeginMap; |
| out << Key << VerbatimTag("!foo") << Null; |
| out << Value << "baz"; |
| out << EndMap; |
| |
| ExpectEmit("{!<!foo> ~: baz}"); |
| } |
| |
| TEST_F(EmitterTest, VerbatimTagWithEmptySeq) { |
| out << VerbatimTag("!foo") << BeginSeq << EndSeq; |
| |
| ExpectEmit("!<!foo>\n[]"); |
| } |
| |
| TEST_F(EmitterTest, VerbatimTagWithEmptyMap) { |
| out << VerbatimTag("!bar") << BeginMap << EndMap; |
| |
| ExpectEmit("!<!bar>\n{}"); |
| } |
| |
| TEST_F(EmitterTest, VerbatimTagWithEmptySeqAndMap) { |
| out << BeginSeq; |
| out << VerbatimTag("!foo") << BeginSeq << EndSeq; |
| out << VerbatimTag("!bar") << BeginMap << EndMap; |
| out << EndSeq; |
| |
| ExpectEmit("- !<!foo>\n []\n- !<!bar>\n {}"); |
| } |
| |
| TEST_F(EmitterTest, ByKindTagWithScalar) { |
| out << BeginSeq; |
| out << DoubleQuoted << "12"; |
| out << "12"; |
| out << TagByKind << "12"; |
| out << EndSeq; |
| |
| ExpectEmit("- \"12\"\n- 12\n- ! 12"); |
| } |
| |
| TEST_F(EmitterTest, LocalTagInNameHandle) { |
| out << LocalTag("a", "foo") << "bar"; |
| |
| ExpectEmit("!a!foo bar"); |
| } |
| |
| TEST_F(EmitterTest, LocalTagWithScalar) { |
| out << LocalTag("foo") << "bar"; |
| |
| ExpectEmit("!foo bar"); |
| } |
| |
| TEST_F(EmitterTest, ComplexDoc) { |
| out << BeginMap; |
| out << Key << "receipt"; |
| out << Value << "Oz-Ware Purchase Invoice"; |
| out << Key << "date"; |
| out << Value << "2007-08-06"; |
| out << Key << "customer"; |
| out << Value; |
| out << BeginMap; |
| out << Key << "given"; |
| out << Value << "Dorothy"; |
| out << Key << "family"; |
| out << Value << "Gale"; |
| out << EndMap; |
| out << Key << "items"; |
| out << Value; |
| out << BeginSeq; |
| out << BeginMap; |
| out << Key << "part_no"; |
| out << Value << "A4786"; |
| out << Key << "descrip"; |
| out << Value << "Water Bucket (Filled)"; |
| out << Key << "price"; |
| out << Value << 1.47; |
| out << Key << "quantity"; |
| out << Value << 4; |
| out << EndMap; |
| out << BeginMap; |
| out << Key << "part_no"; |
| out << Value << "E1628"; |
| out << Key << "descrip"; |
| out << Value << "High Heeled \"Ruby\" Slippers"; |
| out << Key << "price"; |
| out << Value << 100.27; |
| out << Key << "quantity"; |
| out << Value << 1; |
| out << EndMap; |
| out << EndSeq; |
| out << Key << "bill-to"; |
| out << Value << Anchor("id001"); |
| out << BeginMap; |
| out << Key << "street"; |
| out << Value << Literal << "123 Tornado Alley\nSuite 16"; |
| out << Key << "city"; |
| out << Value << "East Westville"; |
| out << Key << "state"; |
| out << Value << "KS"; |
| out << EndMap; |
| out << Key << "ship-to"; |
| out << Value << Alias("id001"); |
| out << EndMap; |
| |
| ExpectEmit( |
| "receipt: Oz-Ware Purchase Invoice\ndate: 2007-08-06\ncustomer:\n " |
| "given: Dorothy\n family: Gale\nitems:\n - part_no: A4786\n " |
| "descrip: Water Bucket (Filled)\n price: 1.47\n quantity: 4\n - " |
| "part_no: E1628\n descrip: High Heeled \"Ruby\" Slippers\n price: " |
| "100.27\n quantity: 1\nbill-to: &id001\n street: |\n 123 Tornado " |
| "Alley\n Suite 16\n city: East Westville\n state: KS\nship-to: " |
| "*id001"); |
| } |
| |
| TEST_F(EmitterTest, STLContainers) { |
| out << BeginSeq; |
| std::vector<int> primes; |
| primes.push_back(2); |
| primes.push_back(3); |
| primes.push_back(5); |
| primes.push_back(7); |
| primes.push_back(11); |
| primes.push_back(13); |
| out << Flow << primes; |
| std::map<std::string, int> ages; |
| ages["Daniel"] = 26; |
| ages["Jesse"] = 24; |
| out << ages; |
| out << EndSeq; |
| |
| ExpectEmit("- [2, 3, 5, 7, 11, 13]\n- Daniel: 26\n Jesse: 24"); |
| } |
| |
| TEST_F(EmitterTest, CommentStyle) { |
| out.SetPreCommentIndent(1); |
| out.SetPostCommentIndent(2); |
| out << BeginMap; |
| out << Key << "method"; |
| out << Value << "least squares" << Comment("should we change this method?"); |
| out << EndMap; |
| |
| ExpectEmit("method: least squares # should we change this method?"); |
| } |
| |
| TEST_F(EmitterTest, SimpleComment) { |
| out << BeginMap; |
| out << Key << "method"; |
| out << Value << "least squares" << Comment("should we change this method?"); |
| out << EndMap; |
| |
| ExpectEmit("method: least squares # should we change this method?"); |
| } |
| |
| TEST_F(EmitterTest, MultiLineComment) { |
| out << BeginSeq; |
| out << "item 1" |
| << Comment( |
| "really really long\ncomment that couldn't " |
| "possibly\nfit on one line"); |
| out << "item 2"; |
| out << EndSeq; |
| |
| ExpectEmit( |
| "- item 1 # really really long\n # comment that couldn't " |
| "possibly\n # fit on one line\n- item 2"); |
| } |
| |
| TEST_F(EmitterTest, ComplexComments) { |
| out << BeginMap; |
| out << LongKey << Key << "long key" << Comment("long key"); |
| out << Value << "value"; |
| out << EndMap; |
| |
| ExpectEmit("? long key # long key\n: value"); |
| } |
| |
| TEST_F(EmitterTest, InitialComment) { |
| out << Comment("A comment describing the purpose of the file."); |
| out << BeginMap << Key << "key" << Value << "value" << EndMap; |
| |
| ExpectEmit("# A comment describing the purpose of the file.\nkey: value"); |
| } |
| |
| TEST_F(EmitterTest, InitialCommentWithDocIndicator) { |
| out << BeginDoc << Comment("A comment describing the purpose of the file."); |
| out << BeginMap << Key << "key" << Value << "value" << EndMap; |
| |
| ExpectEmit( |
| "---\n# A comment describing the purpose of the file.\nkey: value"); |
| } |
| |
| TEST_F(EmitterTest, CommentInFlowSeq) { |
| out << Flow << BeginSeq << "foo" << Comment("foo!") << "bar" << EndSeq; |
| |
| ExpectEmit("[foo, # foo!\nbar]"); |
| } |
| |
| TEST_F(EmitterTest, CommentInFlowMap) { |
| out << Flow << BeginMap; |
| out << Key << "foo" << Value << "foo value"; |
| out << Key << "bar" << Value << "bar value" << Comment("bar!"); |
| out << Key << "baz" << Value << "baz value" << Comment("baz!"); |
| out << EndMap; |
| |
| ExpectEmit( |
| "{foo: foo value, bar: bar value, # bar!\nbaz: baz value, # baz!\n}"); |
| } |
| |
| TEST_F(EmitterTest, Indentation) { |
| out << Indent(4); |
| out << BeginSeq; |
| out << BeginMap; |
| out << Key << "key 1" << Value << "value 1"; |
| out << Key << "key 2" << Value << BeginSeq << "a" |
| << "b" |
| << "c" << EndSeq; |
| out << EndMap; |
| out << EndSeq; |
| |
| ExpectEmit( |
| "- key 1: value 1\n key 2:\n - a\n - b\n - " |
| " c"); |
| } |
| |
| TEST_F(EmitterTest, SimpleGlobalSettings) { |
| out.SetIndent(4); |
| out.SetMapFormat(LongKey); |
| |
| out << BeginSeq; |
| out << BeginMap; |
| out << Key << "key 1" << Value << "value 1"; |
| out << Key << "key 2" << Value << Flow << BeginSeq << "a" |
| << "b" |
| << "c" << EndSeq; |
| out << EndMap; |
| out << EndSeq; |
| |
| ExpectEmit("- ? key 1\n : value 1\n ? key 2\n : [a, b, c]"); |
| } |
| |
| TEST_F(EmitterTest, GlobalLongKeyOnSeq) { |
| out.SetMapFormat(LongKey); |
| |
| out << BeginMap; |
| out << Key << Anchor("key"); |
| out << BeginSeq << "a" |
| << "b" << EndSeq; |
| out << Value << Anchor("value"); |
| out << BeginSeq << "c" |
| << "d" << EndSeq; |
| out << Key << Alias("key") << Value << Alias("value"); |
| out << EndMap; |
| |
| ExpectEmit(R"(? &key |
| - a |
| - b |
| : &value |
| - c |
| - d |
| ? *key |
| : *value)"); |
| } |
| |
| TEST_F(EmitterTest, GlobalLongKeyOnMap) { |
| out.SetMapFormat(LongKey); |
| |
| out << BeginMap; |
| out << Key << Anchor("key"); |
| out << BeginMap << "a" |
| << "b" << EndMap; |
| out << Value << Anchor("value"); |
| out << BeginMap << "c" |
| << "d" << EndMap; |
| out << Key << Alias("key") << Value << Alias("value"); |
| out << EndMap; |
| |
| ExpectEmit(R"(? &key |
| ? a |
| : b |
| : &value |
| ? c |
| : d |
| ? *key |
| : *value)"); |
| } |
| |
| TEST_F(EmitterTest, GlobalSettingStyleOnSeqNode) { |
| Node n(Load(R"(foo: |
| - 1 |
| - 2 |
| - 3 |
| bar: aa)")); |
| out.SetSeqFormat(YAML::Flow); |
| out << n; |
| ExpectEmit(R"(foo: [1, 2, 3] |
| bar: aa)"); |
| } |
| |
| TEST_F(EmitterTest, GlobalSettingStyleOnMapNode) { |
| Node n(Load(R"(- |
| foo: a |
| bar: b |
| - 2 |
| - 3)")); |
| out.SetMapFormat(YAML::Flow); |
| out << n; |
| ExpectEmit(R"(- {foo: a, bar: b} |
| - 2 |
| - 3)"); |
| } |
| |
| TEST_F(EmitterTest, ComplexGlobalSettings) { |
| out << BeginSeq; |
| out << Block; |
| out << BeginMap; |
| out << Key << "key 1" << Value << "value 1"; |
| out << Key << "key 2" << Value; |
| out.SetSeqFormat(Flow); |
| out << BeginSeq << "a" |
| << "b" |
| << "c" << EndSeq; |
| out << EndMap; |
| out << BeginMap; |
| out << Key << BeginSeq << 1 << 2 << EndSeq; |
| out << Value << BeginMap << Key << "a" << Value << "b" << EndMap; |
| out << EndMap; |
| out << EndSeq; |
| |
| ExpectEmit("- key 1: value 1\n key 2: [a, b, c]\n- [1, 2]:\n a: b"); |
| } |
| |
| TEST_F(EmitterTest, Null) { |
| out << BeginSeq; |
| out << Null; |
| out << BeginMap; |
| out << Key << "null value" << Value << Null; |
| out << Key << Null << Value << "null key"; |
| out << EndMap; |
| out << EndSeq; |
| |
| ExpectEmit("- ~\n- null value: ~\n ~: null key"); |
| } |
| |
| TEST_F(EmitterTest, OutputCharset) { |
| out << BeginSeq; |
| out.SetOutputCharset(EmitNonAscii); |
| out << "\x24 \xC2\xA2 \xE2\x82\xAC"; |
| out.SetOutputCharset(EscapeNonAscii); |
| out << "\x24 \xC2\xA2 \xE2\x82\xAC"; |
| out << EndSeq; |
| |
| ExpectEmit("- \x24 \xC2\xA2 \xE2\x82\xAC\n- \"\x24 \\xa2 \\u20ac\""); |
| } |
| |
| TEST_F(EmitterTest, EscapedUnicode) { |
| out << EscapeNonAscii << "\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2"; |
| |
| ExpectEmit("\"$ \\xa2 \\u20ac \\U00024b62\""); |
| } |
| |
| TEST_F(EmitterTest, Unicode) { |
| out << "\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2"; |
| ExpectEmit("\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2"); |
| } |
| |
| TEST_F(EmitterTest, DoubleQuotedUnicode) { |
| out << DoubleQuoted << "\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2"; |
| ExpectEmit("\"\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2\""); |
| } |
| |
| TEST_F(EmitterTest, EscapedJsonString) { |
| out.SetStringFormat(DoubleQuoted); |
| out.SetOutputCharset(EscapeAsJson); |
| out << "\" \\ " |
| "\x01 \x02 \x03 \x04 \x05 \x06 \x07 \x08 \x09 \x0A \x0B \x0C \x0D \x0E \x0F " |
| "\x10 \x11 \x12 \x13 \x14 \x15 \x16 \x17 \x18 \x19 \x1A \x1B \x1C \x1D \x1E \x1F " |
| "\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2"; |
| |
| ExpectEmit(R"("\" \\ \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t )" |
| R"(\n \u000b \f \r \u000e \u000f \u0010 \u0011 \u0012 \u0013 )" |
| R"(\u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b )" |
| R"(\u001c \u001d \u001e \u001f )" |
| "$ \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2\""); |
| } |
| |
| TEST_F(EmitterTest, EscapedCharacters) { |
| out << BeginSeq |
| << '\x00' |
| << '\x0C' |
| << '\x0D' |
| << EndSeq; |
| |
| ExpectEmit("- \"\\x00\"\n- \"\\f\"\n- \"\\r\""); |
| } |
| |
| TEST_F(EmitterTest, CharactersEscapedAsJson) { |
| out.SetOutputCharset(EscapeAsJson); |
| out << BeginSeq |
| << '\x00' |
| << '\x0C' |
| << '\x0D' |
| << EndSeq; |
| |
| ExpectEmit("- \"\\u0000\"\n- \"\\f\"\n- \"\\r\""); |
| } |
| |
| TEST_F(EmitterTest, DoubleQuotedString) { |
| out << DoubleQuoted << "\" \\ \n \t \r \b \x15 \xEF\xBB\xBF \x24"; |
| ExpectEmit("\"\\\" \\\\ \\n \\t \\r \\b \\x15 \\ufeff $\""); |
| } |
| |
| struct Foo { |
| Foo() : x(0) {} |
| Foo(int x_, const std::string& bar_) : x(x_), bar(bar_) {} |
| |
| int x; |
| std::string bar; |
| }; |
| |
| Emitter& operator<<(Emitter& out, const Foo& foo) { |
| out << BeginMap; |
| out << Key << "x" << Value << foo.x; |
| out << Key << "bar" << Value << foo.bar; |
| out << EndMap; |
| return out; |
| } |
| |
| TEST_F(EmitterTest, UserType) { |
| out << BeginSeq; |
| out << Foo(5, "hello"); |
| out << Foo(3, "goodbye"); |
| out << EndSeq; |
| |
| ExpectEmit("- x: 5\n bar: hello\n- x: 3\n bar: goodbye"); |
| } |
| |
| TEST_F(EmitterTest, UserType2) { |
| out << BeginSeq; |
| out << Foo(5, "\r"); |
| out << EndSeq; |
| |
| ExpectEmit("- x: 5\n bar: \"\\r\""); |
| } |
| |
| TEST_F(EmitterTest, UserTypeInContainer) { |
| std::vector<Foo> fv; |
| fv.push_back(Foo(5, "hello")); |
| fv.push_back(Foo(3, "goodbye")); |
| out << fv; |
| |
| ExpectEmit("- x: 5\n bar: hello\n- x: 3\n bar: goodbye"); |
| } |
| |
| template <typename T> |
| Emitter& operator<<(Emitter& out, const T* v) { |
| if (v) |
| out << *v; |
| else |
| out << Null; |
| return out; |
| } |
| |
| TEST_F(EmitterTest, PointerToInt) { |
| int foo = 5; |
| int* bar = &foo; |
| int* baz = 0; |
| out << BeginSeq; |
| out << bar << baz; |
| out << EndSeq; |
| |
| ExpectEmit("- 5\n- ~"); |
| } |
| |
| TEST_F(EmitterTest, PointerToUserType) { |
| Foo foo(5, "hello"); |
| Foo* bar = &foo; |
| Foo* baz = 0; |
| out << BeginSeq; |
| out << bar << baz; |
| out << EndSeq; |
| |
| ExpectEmit("- x: 5\n bar: hello\n- ~"); |
| } |
| |
| TEST_F(EmitterTest, NewlineAtEnd) { |
| out << "Hello" << Newline << Newline; |
| ExpectEmit("Hello\n\n"); |
| } |
| |
| TEST_F(EmitterTest, NewlineInBlockSequence) { |
| out << BeginSeq; |
| out << "a" << Newline << "b" |
| << "c" << Newline << "d"; |
| out << EndSeq; |
| ExpectEmit("- a\n\n- b\n- c\n\n- d"); |
| } |
| |
| TEST_F(EmitterTest, NewlineInFlowSequence) { |
| out << Flow << BeginSeq; |
| out << "a" << Newline << "b" |
| << "c" << Newline << "d"; |
| out << EndSeq; |
| ExpectEmit("[a,\nb, c,\nd]"); |
| } |
| |
| TEST_F(EmitterTest, NewlineInBlockMap) { |
| out << BeginMap; |
| out << Key << "a" << Value << "foo" << Newline; |
| out << Key << "b" << Newline << Value << "bar"; |
| out << LongKey << Key << "c" << Newline << Value << "car"; |
| out << EndMap; |
| ExpectEmit("a: foo\nb:\n bar\n? c\n\n: car"); |
| } |
| |
| TEST_F(EmitterTest, NewlineInFlowMap) { |
| out << Flow << BeginMap; |
| out << Key << "a" << Value << "foo" << Newline; |
| out << Key << "b" << Value << "bar"; |
| out << EndMap; |
| ExpectEmit("{a: foo,\nb: bar}"); |
| } |
| |
| TEST_F(EmitterTest, LotsOfNewlines) { |
| out << BeginSeq; |
| out << "a" << Newline; |
| out << BeginSeq; |
| out << "b" |
| << "c" << Newline; |
| out << EndSeq; |
| out << Newline; |
| out << BeginMap; |
| out << Newline << Key << "d" << Value << Newline << "e"; |
| out << LongKey << Key << "f" << Newline << Value << "foo"; |
| out << EndMap; |
| out << EndSeq; |
| ExpectEmit("- a\n\n-\n - b\n - c\n\n\n-\n d:\n e\n ? f\n\n : foo"); |
| } |
| |
| TEST_F(EmitterTest, Binary) { |
| out << Binary(reinterpret_cast<const unsigned char*>("Hello, World!"), 13); |
| ExpectEmit("!!binary \"SGVsbG8sIFdvcmxkIQ==\""); |
| } |
| |
| TEST_F(EmitterTest, LongBinary) { |
| out << Binary( |
| reinterpret_cast<const unsigned char*>( |
| "Man is distinguished, not only by his reason, but by this " |
| "singular passion from other animals, which is a lust of the " |
| "mind, that by a perseverance of delight in the continued and " |
| "indefatigable generation of knowledge, exceeds the short " |
| "vehemence of any carnal pleasure.\n"), |
| 270); |
| ExpectEmit( |
| "!!binary " |
| "\"TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieS" |
| "B0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIG" |
| "x1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbi" |
| "B0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZG" |
| "dlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS" |
| "4K\""); |
| } |
| |
| TEST_F(EmitterTest, EmptyBinary) { |
| out << Binary(reinterpret_cast<const unsigned char*>(""), 0); |
| ExpectEmit("!!binary \"\""); |
| } |
| |
| TEST_F(EmitterTest, ColonAtEndOfScalar) { |
| out << "a:"; |
| ExpectEmit("\"a:\""); |
| } |
| |
| TEST_F(EmitterTest, ColonAsScalar) { |
| out << BeginMap; |
| out << Key << "apple" << Value << ":"; |
| out << Key << "banana" << Value << ":"; |
| out << EndMap; |
| ExpectEmit("apple: \":\"\nbanana: \":\""); |
| } |
| |
| TEST_F(EmitterTest, ColonAtEndOfScalarInFlow) { |
| out << Flow << BeginMap << Key << "C:" << Value << "C:" << EndMap; |
| ExpectEmit("{\"C:\": \"C:\"}"); |
| } |
| |
| TEST_F(EmitterTest, GlobalBoolFormatting) { |
| out << BeginSeq; |
| out.SetBoolFormat(UpperCase); |
| out.SetBoolFormat(YesNoBool); |
| out << true; |
| out << false; |
| out.SetBoolFormat(TrueFalseBool); |
| out << true; |
| out << false; |
| out.SetBoolFormat(OnOffBool); |
| out << true; |
| out << false; |
| out.SetBoolFormat(LowerCase); |
| out.SetBoolFormat(YesNoBool); |
| out << true; |
| out << false; |
| out.SetBoolFormat(TrueFalseBool); |
| out << true; |
| out << false; |
| out.SetBoolFormat(OnOffBool); |
| out << true; |
| out << false; |
| out.SetBoolFormat(CamelCase); |
| out.SetBoolFormat(YesNoBool); |
| out << true; |
| out << false; |
| out.SetBoolFormat(TrueFalseBool); |
| out << true; |
| out << false; |
| out.SetBoolFormat(OnOffBool); |
| out << true; |
| out << false; |
| out.SetBoolFormat(ShortBool); |
| out.SetBoolFormat(UpperCase); |
| out.SetBoolFormat(YesNoBool); |
| out << true; |
| out << false; |
| out.SetBoolFormat(TrueFalseBool); |
| out << true; |
| out << false; |
| out.SetBoolFormat(OnOffBool); |
| out << true; |
| out << false; |
| out << EndSeq; |
| ExpectEmit( |
| "- YES\n- NO\n- TRUE\n- FALSE\n- ON\n- OFF\n" |
| "- yes\n- no\n- true\n- false\n- on\n- off\n" |
| "- Yes\n- No\n- True\n- False\n- On\n- Off\n" |
| "- Y\n- N\n- Y\n- N\n- Y\n- N"); |
| } |
| |
| TEST_F(EmitterTest, BoolFormatting) { |
| out << BeginSeq; |
| out << TrueFalseBool << UpperCase << true; |
| out << TrueFalseBool << CamelCase << true; |
| out << TrueFalseBool << LowerCase << true; |
| out << TrueFalseBool << UpperCase << false; |
| out << TrueFalseBool << CamelCase << false; |
| out << TrueFalseBool << LowerCase << false; |
| out << YesNoBool << UpperCase << true; |
| out << YesNoBool << CamelCase << true; |
| out << YesNoBool << LowerCase << true; |
| out << YesNoBool << UpperCase << false; |
| out << YesNoBool << CamelCase << false; |
| out << YesNoBool << LowerCase << false; |
| out << OnOffBool << UpperCase << true; |
| out << OnOffBool << CamelCase << true; |
| out << OnOffBool << LowerCase << true; |
| out << OnOffBool << UpperCase << false; |
| out << OnOffBool << CamelCase << false; |
| out << OnOffBool << LowerCase << false; |
| out << ShortBool << UpperCase << true; |
| out << ShortBool << CamelCase << true; |
| out << ShortBool << LowerCase << true; |
| out << ShortBool << UpperCase << false; |
| out << ShortBool << CamelCase << false; |
| out << ShortBool << LowerCase << false; |
| out << EndSeq; |
| ExpectEmit( |
| "- TRUE\n- True\n- true\n- FALSE\n- False\n- false\n" |
| "- YES\n- Yes\n- yes\n- NO\n- No\n- no\n" |
| "- ON\n- On\n- on\n- OFF\n- Off\n- off\n" |
| "- Y\n- Y\n- y\n- N\n- N\n- n"); |
| } |
| |
| TEST_F(EmitterTest, GlobalNullFormatting) { |
| out << Flow << BeginSeq; |
| out.SetNullFormat(LowerNull); |
| out << Null; |
| out.SetNullFormat(UpperNull); |
| out << Null; |
| out.SetNullFormat(CamelNull); |
| out << Null; |
| out.SetNullFormat(TildeNull); |
| out << Null; |
| out << EndSeq; |
| ExpectEmit("[null, NULL, Null, ~]"); |
| } |
| |
| TEST_F(EmitterTest, NullFormatting) { |
| out << Flow << BeginSeq; |
| out << LowerNull << Null; |
| out << UpperNull << Null; |
| out << CamelNull << Null; |
| out << TildeNull << Null; |
| out << EndSeq; |
| ExpectEmit("[null, NULL, Null, ~]"); |
| } |
| |
| TEST_F(EmitterTest, NullFormattingOnNode) { |
| Node n(Load("null")); |
| out << Flow << BeginSeq; |
| out.SetNullFormat(LowerNull); |
| out << n; |
| out.SetNullFormat(UpperNull); |
| out << n; |
| out.SetNullFormat(CamelNull); |
| out << n; |
| out.SetNullFormat(TildeNull); |
| out << n; |
| out << EndSeq; |
| ExpectEmit("[null, NULL, Null, ~]"); |
| } |
| |
| // TODO: Fix this test. |
| // TEST_F(EmitterTest, DocStartAndEnd) { |
| // out << BeginDoc; |
| // out << BeginSeq << 1 << 2 << 3 << EndSeq; |
| // out << BeginDoc; |
| // out << "Hi there!"; |
| // out << EndDoc; |
| // out << EndDoc; |
| // out << EndDoc; |
| // out << BeginDoc; |
| // out << VerbatimTag("foo") << "bar"; |
| // ExpectEmit( |
| // "---\n- 1\n- 2\n- 3\n---\nHi there!\n...\n...\n...\n---\n!<foo> bar"); |
| //} |
| |
| TEST_F(EmitterTest, ImplicitDocStart) { |
| out << "Hi"; |
| out << "Bye"; |
| out << "Oops"; |
| ExpectEmit("Hi\n---\nBye\n---\nOops"); |
| } |
| |
| TEST_F(EmitterTest, EmptyString) { |
| out << BeginMap; |
| out << Key << "key" << Value << ""; |
| out << EndMap; |
| ExpectEmit("key: \"\""); |
| } |
| |
| TEST_F(EmitterTest, SingleChar) { |
| out << BeginSeq; |
| out << 'a'; |
| out << ':'; |
| out << (char)0x10; |
| out << '\n'; |
| out << ' '; |
| out << '\t'; |
| out << EndSeq; |
| ExpectEmit("- a\n- \":\"\n- \"\\x10\"\n- \"\\n\"\n- \" \"\n- \"\\t\""); |
| } |
| |
| TEST_F(EmitterTest, DefaultPrecision) { |
| out << BeginSeq; |
| out << 1.3125f; |
| out << 1.23455810546875; |
| out << EndSeq; |
| ExpectEmit("- 1.3125\n- 1.23455810546875"); |
| } |
| |
| TEST_F(EmitterTest, SetPrecision) { |
| out << BeginSeq; |
| out << FloatPrecision(3) << 1.3125f; |
| out << DoublePrecision(6) << 1.23455810546875; |
| out << EndSeq; |
| ExpectEmit("- 1.31\n- 1.23456"); |
| } |
| |
| TEST_F(EmitterTest, DashInBlockContext) { |
| out << BeginMap; |
| out << Key << "key" << Value << "-"; |
| out << EndMap; |
| ExpectEmit("key: \"-\""); |
| } |
| |
| TEST_F(EmitterTest, HexAndOct) { |
| out << Flow << BeginSeq; |
| out << 31; |
| out << Hex << 31; |
| out << Oct << 31; |
| out << EndSeq; |
| ExpectEmit("[31, 0x1f, 037]"); |
| } |
| |
| TEST_F(EmitterTest, CompactMapWithNewline) { |
| out << Comment("Characteristics"); |
| out << BeginSeq; |
| out << BeginMap; |
| out << Key << "color" << Value << "blue"; |
| out << Key << "height" << Value << 120; |
| out << EndMap; |
| out << Newline << Newline; |
| out << Comment("Skills"); |
| out << BeginMap; |
| out << Key << "attack" << Value << 23; |
| out << Key << "intelligence" << Value << 56; |
| out << EndMap; |
| out << EndSeq; |
| |
| ExpectEmit( |
| "# Characteristics\n" |
| "- color: blue\n" |
| " height: 120\n" |
| "\n" |
| "# Skills\n" |
| "- attack: 23\n" |
| " intelligence: 56"); |
| } |
| |
| TEST_F(EmitterTest, ForceSingleQuotedToDouble) { |
| out << SingleQuoted << "Hello\nWorld"; |
| |
| ExpectEmit("\"Hello\\nWorld\""); |
| } |
| |
| TEST_F(EmitterTest, QuoteNull) { |
| out << "null"; |
| |
| ExpectEmit("\"null\""); |
| } |
| |
| TEST_F(EmitterTest, ValueOfDoubleQuote) { |
| out << YAML::BeginMap; |
| out << YAML::Key << "foo" << YAML::Value << '"'; |
| out << YAML::EndMap; |
| |
| ExpectEmit("foo: \"\\\"\""); |
| } |
| |
| TEST_F(EmitterTest, ValueOfBackslash) { |
| out << YAML::BeginMap; |
| out << YAML::Key << "foo" << YAML::Value << '\\'; |
| out << YAML::EndMap; |
| |
| ExpectEmit("foo: \"\\\\\""); |
| } |
| |
| TEST_F(EmitterTest, Infinity) { |
| out << YAML::BeginMap; |
| out << YAML::Key << "foo" << YAML::Value |
| << std::numeric_limits<float>::infinity(); |
| out << YAML::Key << "bar" << YAML::Value |
| << std::numeric_limits<double>::infinity(); |
| out << YAML::EndMap; |
| |
| ExpectEmit( |
| "foo: .inf\n" |
| "bar: .inf"); |
| } |
| |
| TEST_F(EmitterTest, NegInfinity) { |
| out << YAML::BeginMap; |
| out << YAML::Key << "foo" << YAML::Value |
| << -std::numeric_limits<float>::infinity(); |
| out << YAML::Key << "bar" << YAML::Value |
| << -std::numeric_limits<double>::infinity(); |
| out << YAML::EndMap; |
| |
| ExpectEmit( |
| "foo: -.inf\n" |
| "bar: -.inf"); |
| } |
| |
| TEST_F(EmitterTest, NaN) { |
| out << YAML::BeginMap; |
| out << YAML::Key << "foo" << YAML::Value |
| << std::numeric_limits<float>::quiet_NaN(); |
| out << YAML::Key << "bar" << YAML::Value |
| << std::numeric_limits<double>::quiet_NaN(); |
| out << YAML::EndMap; |
| |
| ExpectEmit( |
| "foo: .nan\n" |
| "bar: .nan"); |
| } |
| |
| TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapWithNewLine) { |
| out << YAML::BeginMap; |
| |
| out << YAML::Key << "NodeA" << YAML::Value << YAML::BeginMap; |
| out << YAML::Key << "k" << YAML::Value << YAML::Flow << YAML::BeginSeq; |
| out << YAML::BeginMap << YAML::Key << "i" << YAML::Value << 0 << YAML::EndMap |
| << YAML::Newline; |
| out << YAML::BeginMap << YAML::Key << "i" << YAML::Value << 1 << YAML::EndMap |
| << YAML::Newline; |
| out << YAML::EndSeq; |
| out << YAML::EndMap; |
| |
| out << YAML::Key << "NodeB" << YAML::Value << YAML::BeginMap; |
| out << YAML::Key << "k" << YAML::Value << YAML::Flow << YAML::BeginSeq; |
| out << YAML::BeginMap << YAML::Key << "i" << YAML::Value << 0 << YAML::EndMap |
| << YAML::Newline; |
| out << YAML::BeginMap << YAML::Key << "i" << YAML::Value << 1 << YAML::EndMap |
| << YAML::Newline; |
| out << YAML::EndSeq; |
| out << YAML::EndMap; |
| |
| out << YAML::EndMap; |
| |
| ExpectEmit(R"(NodeA: |
| k: [{i: 0}, |
| {i: 1}, |
| ] |
| NodeB: |
| k: [{i: 0}, |
| {i: 1}, |
| ])"); |
| } |
| |
| TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapWithNewLineUsingAliases) { |
| out << BeginMap; |
| |
| out << Key << "Node" << Anchor("Node") << Value << BeginMap; |
| out << Key << "k" << Value << Flow << BeginSeq; |
| out << BeginMap << Key << "i" << Value << 0 << EndMap; |
| out << YAML::Newline; |
| out << BeginMap << Key << "i" << Value << 1 << EndMap; |
| out << YAML::Newline; |
| out << EndSeq << EndMap; |
| |
| out << Key << "NodeA" << Alias("Node"); |
| out << Key << "NodeB" << Alias("Node"); |
| |
| out << EndMap; |
| |
| ExpectEmit(R"(Node: &Node |
| k: [{i: 0}, |
| {i: 1}, |
| ] |
| NodeA: *Node |
| NodeB: *Node)"); |
| } |
| |
| TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapUsingAliases) { |
| out << BeginMap; |
| |
| out << Key << "Node" << Anchor("Node") << Value << BeginMap; |
| out << Key << "k" << Value << Flow << BeginSeq; |
| out << BeginMap << Key << "i" << Value << 0 << EndMap; |
| out << BeginMap << Key << "i" << Value << 1 << EndMap; |
| out << EndSeq << EndMap; |
| |
| out << Key << "NodeA" << Alias("Node"); |
| out << Key << "NodeB" << Alias("Node"); |
| |
| out << EndMap; |
| |
| ExpectEmit(R"(Node: &Node |
| k: [{i: 0}, {i: 1}] |
| NodeA: *Node |
| NodeB: *Node)"); |
| } |
| |
| TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapWithNewLineUsingAliases2) { |
| out << BeginMap; |
| |
| out << Key << "Seq" << Anchor("Seq") << Flow << BeginSeq; |
| out << BeginMap << Key << "i" << Value << 0 << EndMap; |
| out << YAML::Newline; |
| out << BeginMap << Key << "i" << Value << 1 << EndMap; |
| out << YAML::Newline; |
| out << EndSeq; |
| |
| out << Key << "NodeA" << Value << BeginMap; |
| out << Key << "k" << Value << Alias("Seq") << EndMap; |
| out << Key << "NodeB" << Value << BeginMap; |
| out << Key << "k" << Value << Alias("Seq") << EndMap; |
| |
| out << EndMap; |
| |
| ExpectEmit(R"(Seq: &Seq [{i: 0}, |
| {i: 1}, |
| ] |
| NodeA: |
| k: *Seq |
| NodeB: |
| k: *Seq)"); |
| } |
| |
| TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapUsingAliases2) { |
| out << BeginMap; |
| |
| out << Key << "Seq" << Anchor("Seq") << Value << Flow << BeginSeq; |
| out << BeginMap << Key << "i" << Value << 0 << EndMap; |
| out << BeginMap << Key << "i" << Value << 1 << EndMap; |
| out << EndSeq; |
| |
| out << Key << "NodeA" << Value << BeginMap; |
| out << Key << "k" << Value << Alias("Seq") << EndMap; |
| out << Key << "NodeB" << Value << BeginMap; |
| out << Key << "k" << Value << Alias("Seq") << EndMap; |
| |
| out << EndMap; |
| |
| ExpectEmit(R"(Seq: &Seq [{i: 0}, {i: 1}] |
| NodeA: |
| k: *Seq |
| NodeB: |
| k: *Seq)"); |
| } |
| |
| TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapWithNewLineUsingAliases3) { |
| out << BeginMap; |
| |
| out << Key << "Keys" << Value << Flow << BeginSeq; |
| out << Anchor("k0") << BeginMap << Key << "i" << Value << 0 << EndMap |
| << Newline; |
| out << Anchor("k1") << BeginMap << Key << "i" << Value << 1 << EndMap |
| << Newline; |
| out << EndSeq; |
| |
| out << Key << "NodeA" << Value << BeginMap; |
| out << Key << "k" << Value << Flow << BeginSeq; |
| out << Alias("k0") << Newline << Alias("k1") << Newline; |
| out << EndSeq << EndMap; |
| |
| out << Key << "NodeB" << Value << BeginMap; |
| out << Key << "k" << Value << Flow << BeginSeq; |
| out << Alias("k0") << Newline << Alias("k1") << Newline; |
| out << EndSeq << EndMap; |
| |
| out << EndMap; |
| |
| ExpectEmit(R"(Keys: [&k0 {i: 0}, |
| &k1 {i: 1}, |
| ] |
| NodeA: |
| k: [*k0, |
| *k1, |
| ] |
| NodeB: |
| k: [*k0, |
| *k1, |
| ])"); |
| } |
| |
| TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapUsingAliases3a) { |
| out << BeginMap; |
| |
| out << Key << "Keys" << Value << BeginSeq; |
| out << Anchor("k0") << BeginMap << Key << "i" << Value << 0 << EndMap; |
| out << Anchor("k1") << BeginMap << Key << "i" << Value << 1 << EndMap; |
| out << EndSeq; |
| |
| out << Key << "NodeA" << Value << BeginMap; |
| out << Key << "k" << Value << Flow << BeginSeq; |
| out << Alias("k0") << Alias("k1"); |
| out << EndSeq << EndMap; |
| |
| out << Key << "NodeB" << Value << BeginMap; |
| out << Key << "k" << Value << Flow << BeginSeq; |
| out << Alias("k0") << Alias("k1"); |
| out << EndSeq << EndMap; |
| |
| out << EndMap; |
| |
| ExpectEmit(R"(Keys: |
| - &k0 |
| i: 0 |
| - &k1 |
| i: 1 |
| NodeA: |
| k: [*k0, *k1] |
| NodeB: |
| k: [*k0, *k1])"); |
| } |
| |
| TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapUsingAliases3b) { |
| out << BeginMap; |
| |
| out << Key << "Keys" << Value << Flow << BeginSeq; |
| out << Anchor("k0") << BeginMap << Key << "i" << Value << 0 << EndMap; |
| out << Anchor("k1") << BeginMap << Key << "i" << Value << 1 << EndMap; |
| out << EndSeq; |
| |
| out << Key << "NodeA" << Value << BeginMap; |
| out << Key << "k" << Value << Flow << BeginSeq; |
| out << Alias("k0") << Alias("k1"); |
| out << EndSeq << EndMap; |
| |
| out << Key << "NodeB" << Value << BeginMap; |
| out << Key << "k" << Value << Flow << BeginSeq; |
| out << Alias("k0") << Alias("k1"); |
| out << EndSeq << EndMap; |
| |
| out << EndMap; |
| |
| ExpectEmit(R"(Keys: [&k0 {i: 0}, &k1 {i: 1}] |
| NodeA: |
| k: [*k0, *k1] |
| NodeB: |
| k: [*k0, *k1])"); |
| } |
| |
| TEST_F(EmitterTest, AnchorEncoding) { |
| Node node; |
| node["--- &$ [*$]1"] = 1; |
| out << node; |
| ExpectEmit("\"--- &$ [*$]1\": 1"); |
| Node reparsed = YAML::Load(out.c_str()); |
| EXPECT_EQ(reparsed["--- &$ [*$]1"].as<int>(), 1); |
| } |
| |
| class EmitterErrorTest : public ::testing::Test { |
| protected: |
| void ExpectEmitError(const std::string& expectedError) { |
| ASSERT_FALSE(out.good()) << "Emitter cleanly produced: " << out.c_str(); |
| EXPECT_EQ(expectedError, out.GetLastError()); |
| } |
| |
| Emitter out; |
| }; |
| |
| TEST_F(EmitterErrorTest, BadLocalTag) { |
| out << LocalTag("e!far") << "bar"; |
| |
| ExpectEmitError("invalid tag"); |
| } |
| |
| TEST_F(EmitterErrorTest, BadTagAndTag) { |
| out << VerbatimTag("!far") << VerbatimTag("!foo") << "bar"; |
| ExpectEmitError(ErrorMsg::INVALID_TAG); |
| } |
| |
| TEST_F(EmitterErrorTest, BadAnchorAndAnchor) { |
| out << Anchor("far") << Anchor("foo") << "bar"; |
| ExpectEmitError(ErrorMsg::INVALID_ANCHOR); |
| } |
| |
| TEST_F(EmitterErrorTest, BadEmptyAnchorOnGroup) { |
| out << BeginSeq << "bar" << Anchor("foo") << EndSeq; |
| ExpectEmitError(ErrorMsg::INVALID_ANCHOR); |
| } |
| |
| TEST_F(EmitterErrorTest, BadEmptyTagOnGroup) { |
| out << BeginSeq << "bar" << VerbatimTag("!foo") << EndSeq; |
| ExpectEmitError(ErrorMsg::INVALID_TAG); |
| } |
| |
| TEST_F(EmitterErrorTest, ExtraEndSeq) { |
| out << BeginSeq; |
| out << "Hello"; |
| out << "World"; |
| out << EndSeq; |
| out << EndSeq; |
| |
| ExpectEmitError(ErrorMsg::UNEXPECTED_END_SEQ); |
| } |
| |
| TEST_F(EmitterErrorTest, ExtraEndMap) { |
| out << BeginMap; |
| out << Key << "Hello" << Value << "World"; |
| out << EndMap; |
| out << EndMap; |
| |
| ExpectEmitError(ErrorMsg::UNEXPECTED_END_MAP); |
| } |
| |
| TEST_F(EmitterErrorTest, InvalidAnchor) { |
| out << BeginSeq; |
| out << Anchor("new\nline") << "Test"; |
| out << EndSeq; |
| |
| ExpectEmitError(ErrorMsg::INVALID_ANCHOR); |
| } |
| |
| TEST_F(EmitterErrorTest, InvalidAlias) { |
| out << BeginSeq; |
| out << Alias("new\nline"); |
| out << EndSeq; |
| |
| ExpectEmitError(ErrorMsg::INVALID_ALIAS); |
| } |
| |
| } // namespace |
| } // namespace YAML |
