Switched YAML::Parse to YAML::Load, and added LoadAll
This commit is contained in:
Jesse Beder
parent
5be19ccbfd
commit
e3d5ec189d
@ -5,16 +5,21 @@
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include <string>
|
||||
#include <iosfwd>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace YAML
|
||||
{
|
||||
class Node;
|
||||
|
||||
Node Parse(const std::string& input);
|
||||
Node Parse(const char *input);
|
||||
Node Parse(std::istream& input);
|
||||
Node Load(const std::string& input);
|
||||
Node Load(const char *input);
|
||||
Node Load(std::istream& input);
|
||||
|
||||
std::vector<Node> LoadAll(const std::string& input);
|
||||
std::vector<Node> LoadAll(const char *input);
|
||||
std::vector<Node> LoadAll(std::istream& input);
|
||||
}
|
||||
|
||||
#endif // VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
|
||||
|
||||
@ -8,17 +8,17 @@
|
||||
|
||||
namespace YAML
|
||||
{
|
||||
Node Parse(const std::string& input) {
|
||||
Node Load(const std::string& input) {
|
||||
std::stringstream stream(input);
|
||||
return Parse(stream);
|
||||
return Load(stream);
|
||||
}
|
||||
|
||||
Node Parse(const char *input) {
|
||||
Node Load(const char *input) {
|
||||
std::stringstream stream(input);
|
||||
return Parse(stream);
|
||||
return Load(stream);
|
||||
}
|
||||
|
||||
Node Parse(std::istream& input) {
|
||||
Node Load(std::istream& input) {
|
||||
Parser parser(input);
|
||||
NodeBuilder builder;
|
||||
if(!parser.HandleNextDocument(builder))
|
||||
@ -26,4 +26,28 @@ namespace YAML
|
||||
|
||||
return builder.Root();
|
||||
}
|
||||
|
||||
std::vector<Node> LoadAll(const std::string& input) {
|
||||
std::stringstream stream(input);
|
||||
return LoadAll(stream);
|
||||
}
|
||||
|
||||
std::vector<Node> LoadAll(const char *input) {
|
||||
std::stringstream stream(input);
|
||||
return LoadAll(stream);
|
||||
}
|
||||
|
||||
std::vector<Node> LoadAll(std::istream& input) {
|
||||
std::vector<Node> docs;
|
||||
|
||||
Parser parser(input);
|
||||
while(1) {
|
||||
NodeBuilder builder;
|
||||
if(!parser.HandleNextDocument(builder))
|
||||
break;
|
||||
docs.push_back(builder.Root());
|
||||
}
|
||||
|
||||
return docs;
|
||||
}
|
||||
}
|
||||
|
||||
@ -10,7 +10,7 @@ namespace Test
|
||||
{
|
||||
// 2.1
|
||||
TEST SeqScalars() {
|
||||
YAML::Node doc = YAML::Parse(ex2_1);
|
||||
YAML::Node doc = YAML::Load(ex2_1);
|
||||
YAML_ASSERT(doc.IsSequence());
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc[0].as<std::string>() == "Mark McGwire");
|
||||
@ -21,7 +21,7 @@ namespace Test
|
||||
|
||||
// 2.2
|
||||
TEST MappingScalarsToScalars() {
|
||||
YAML::Node doc = YAML::Parse(ex2_2);
|
||||
YAML::Node doc = YAML::Load(ex2_2);
|
||||
YAML_ASSERT(doc.IsMap());
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc["hr"].as<std::string>() == "65");
|
||||
@ -32,7 +32,7 @@ namespace Test
|
||||
|
||||
// 2.3
|
||||
TEST MappingScalarsToSequences() {
|
||||
YAML::Node doc = YAML::Parse(ex2_3);
|
||||
YAML::Node doc = YAML::Load(ex2_3);
|
||||
YAML_ASSERT(doc.IsMap());
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["american"].size() == 3);
|
||||
@ -48,7 +48,7 @@ namespace Test
|
||||
|
||||
// 2.4
|
||||
TEST SequenceOfMappings() {
|
||||
YAML::Node doc = YAML::Parse(ex2_4);
|
||||
YAML::Node doc = YAML::Load(ex2_4);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc[0].size() == 3);
|
||||
YAML_ASSERT(doc[0]["name"].as<std::string>() == "Mark McGwire");
|
||||
@ -63,7 +63,7 @@ namespace Test
|
||||
|
||||
// 2.5
|
||||
TEST SequenceOfSequences() {
|
||||
YAML::Node doc = YAML::Parse(ex2_5);
|
||||
YAML::Node doc = YAML::Load(ex2_5);
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc[0].size() == 3);
|
||||
YAML_ASSERT(doc[0][0].as<std::string>() == "name");
|
||||
@ -82,7 +82,7 @@ namespace Test
|
||||
|
||||
// 2.6
|
||||
TEST MappingOfMappings() {
|
||||
YAML::Node doc = YAML::Parse(ex2_6);
|
||||
YAML::Node doc = YAML::Load(ex2_6);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["Mark McGwire"].size() == 2);
|
||||
YAML_ASSERT(doc["Mark McGwire"]["hr"].as<std::string>() == "65");
|
||||
@ -105,7 +105,7 @@ namespace Test
|
||||
|
||||
// 2.9
|
||||
TEST SingleDocumentWithTwoComments() {
|
||||
YAML::Node doc = YAML::Parse(ex2_9);
|
||||
YAML::Node doc = YAML::Load(ex2_9);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["hr"].size() == 2);
|
||||
YAML_ASSERT(doc["hr"][0].as<std::string>() == "Mark McGwire");
|
||||
@ -118,7 +118,7 @@ namespace Test
|
||||
|
||||
// 2.10
|
||||
TEST SimpleAnchor() {
|
||||
YAML::Node doc = YAML::Parse(ex2_10);
|
||||
YAML::Node doc = YAML::Load(ex2_10);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["hr"].size() == 2);
|
||||
YAML_ASSERT(doc["hr"][0].as<std::string>() == "Mark McGwire");
|
||||
@ -131,7 +131,7 @@ namespace Test
|
||||
|
||||
// 2.11
|
||||
TEST MappingBetweenSequences() {
|
||||
YAML::Node doc = YAML::Parse(ex2_11);
|
||||
YAML::Node doc = YAML::Load(ex2_11);
|
||||
|
||||
std::vector<std::string> tigers_cubs;
|
||||
tigers_cubs.push_back("Detroit Tigers");
|
||||
@ -154,7 +154,7 @@ namespace Test
|
||||
|
||||
// 2.12
|
||||
TEST CompactNestedMapping() {
|
||||
YAML::Node doc = YAML::Parse(ex2_12);
|
||||
YAML::Node doc = YAML::Load(ex2_12);
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc[0].size() == 2);
|
||||
YAML_ASSERT(doc[0]["item"].as<std::string>() == "Super Hoop");
|
||||
@ -170,7 +170,7 @@ namespace Test
|
||||
|
||||
// 2.13
|
||||
TEST InLiteralsNewlinesArePreserved() {
|
||||
YAML::Node doc = YAML::Parse(ex2_13);
|
||||
YAML::Node doc = YAML::Load(ex2_13);
|
||||
YAML_ASSERT(doc.as<std::string>() ==
|
||||
"\\//||\\/||\n"
|
||||
"// || ||__");
|
||||
@ -179,14 +179,14 @@ namespace Test
|
||||
|
||||
// 2.14
|
||||
TEST InFoldedScalarsNewlinesBecomeSpaces() {
|
||||
YAML::Node doc = YAML::Parse(ex2_14);
|
||||
YAML::Node doc = YAML::Load(ex2_14);
|
||||
YAML_ASSERT(doc.as<std::string>() == "Mark McGwire's year was crippled by a knee injury.");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 2.15
|
||||
TEST FoldedNewlinesArePreservedForMoreIndentedAndBlankLines() {
|
||||
YAML::Node doc = YAML::Parse(ex2_15);
|
||||
YAML::Node doc = YAML::Load(ex2_15);
|
||||
YAML_ASSERT(doc.as<std::string>() ==
|
||||
"Sammy Sosa completed another fine season with great stats.\n\n"
|
||||
" 63 Home Runs\n"
|
||||
@ -197,7 +197,7 @@ namespace Test
|
||||
|
||||
// 2.16
|
||||
TEST IndentationDeterminesScope() {
|
||||
YAML::Node doc = YAML::Parse(ex2_16);
|
||||
YAML::Node doc = YAML::Load(ex2_16);
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc["name"].as<std::string>() == "Mark McGwire");
|
||||
YAML_ASSERT(doc["accomplishment"].as<std::string>() == "Mark set a major league home run record in 1998.\n");
|
||||
@ -207,7 +207,7 @@ namespace Test
|
||||
|
||||
// 2.17
|
||||
TEST QuotedScalars() {
|
||||
YAML::Node doc = YAML::Parse(ex2_17);
|
||||
YAML::Node doc = YAML::Load(ex2_17);
|
||||
YAML_ASSERT(doc.size() == 6);
|
||||
YAML_ASSERT(doc["unicode"].as<std::string>() == "Sosa did fine.\xe2\x98\xba");
|
||||
YAML_ASSERT(doc["control"].as<std::string>() == "\b1998\t1999\t2000\n");
|
||||
@ -220,7 +220,7 @@ namespace Test
|
||||
|
||||
// 2.18
|
||||
TEST MultiLineFlowScalars() {
|
||||
YAML::Node doc = YAML::Parse(ex2_18);
|
||||
YAML::Node doc = YAML::Load(ex2_18);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["plain"].as<std::string>() == "This unquoted scalar spans many lines.");
|
||||
YAML_ASSERT(doc["quoted"].as<std::string>() == "So does this quoted scalar.\n");
|
||||
@ -231,7 +231,7 @@ namespace Test
|
||||
|
||||
// 2.23
|
||||
TEST VariousExplicitTags() {
|
||||
YAML::Node doc = YAML::Parse(ex2_23);
|
||||
YAML::Node doc = YAML::Load(ex2_23);
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc["not-date"].Tag() == "tag:yaml.org,2002:str");
|
||||
YAML_ASSERT(doc["not-date"].as<std::string>() == "2002-04-28");
|
||||
@ -253,7 +253,7 @@ namespace Test
|
||||
|
||||
// 2.24
|
||||
TEST GlobalTags() {
|
||||
YAML::Node doc = YAML::Parse(ex2_24);
|
||||
YAML::Node doc = YAML::Load(ex2_24);
|
||||
YAML_ASSERT(doc.Tag() == "tag:clarkevans.com,2002:shape");
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc[0].Tag() == "tag:clarkevans.com,2002:circle");
|
||||
@ -282,7 +282,7 @@ namespace Test
|
||||
|
||||
// 2.25
|
||||
TEST UnorderedSets() {
|
||||
YAML::Node doc = YAML::Parse(ex2_25);
|
||||
YAML::Node doc = YAML::Load(ex2_25);
|
||||
YAML_ASSERT(doc.Tag() == "tag:yaml.org,2002:set");
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc["Mark McGwire"].IsNull());
|
||||
@ -293,7 +293,7 @@ namespace Test
|
||||
|
||||
// 2.26
|
||||
TEST OrderedMappings() {
|
||||
YAML::Node doc = YAML::Parse(ex2_26);
|
||||
YAML::Node doc = YAML::Load(ex2_26);
|
||||
YAML_ASSERT(doc.Tag() == "tag:yaml.org,2002:omap");
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc[0].size() == 1);
|
||||
@ -307,7 +307,7 @@ namespace Test
|
||||
|
||||
// 2.27
|
||||
TEST Invoice() {
|
||||
YAML::Node doc = YAML::Parse(ex2_27);
|
||||
YAML::Node doc = YAML::Load(ex2_27);
|
||||
YAML_ASSERT(doc.Tag() == "tag:clarkevans.com,2002:invoice");
|
||||
YAML_ASSERT(doc.size() == 8);
|
||||
YAML_ASSERT(doc["invoice"].as<int>() == 34843);
|
||||
@ -352,7 +352,7 @@ namespace Test
|
||||
|
||||
// 5.3
|
||||
TEST BlockStructureIndicators() {
|
||||
YAML::Node doc = YAML::Parse(ex5_3);
|
||||
YAML::Node doc = YAML::Load(ex5_3);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["sequence"].size() == 2);
|
||||
YAML_ASSERT(doc["sequence"][0].as<std::string>() == "one");
|
||||
@ -365,7 +365,7 @@ namespace Test
|
||||
|
||||
// 5.4
|
||||
TEST FlowStructureIndicators() {
|
||||
YAML::Node doc = YAML::Parse(ex5_4);
|
||||
YAML::Node doc = YAML::Load(ex5_4);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["sequence"].size() == 2);
|
||||
YAML_ASSERT(doc["sequence"][0].as<std::string>() == "one");
|
||||
@ -378,14 +378,14 @@ namespace Test
|
||||
|
||||
// 5.5
|
||||
TEST CommentIndicator() {
|
||||
YAML::Node doc = YAML::Parse(ex5_5);
|
||||
YAML::Node doc = YAML::Load(ex5_5);
|
||||
YAML_ASSERT(doc.IsNull());
|
||||
return true;
|
||||
}
|
||||
|
||||
// 5.6
|
||||
TEST NodePropertyIndicators() {
|
||||
YAML::Node doc = YAML::Parse(ex5_6);
|
||||
YAML::Node doc = YAML::Load(ex5_6);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["anchored"].as<std::string>() == "value"); // TODO: assert tag
|
||||
YAML_ASSERT(doc["alias"].as<std::string>() == "value");
|
||||
@ -394,7 +394,7 @@ namespace Test
|
||||
|
||||
// 5.7
|
||||
TEST BlockScalarIndicators() {
|
||||
YAML::Node doc = YAML::Parse(ex5_7);
|
||||
YAML::Node doc = YAML::Load(ex5_7);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["literal"].as<std::string>() == "some\ntext\n");
|
||||
YAML_ASSERT(doc["folded"].as<std::string>() == "some text\n");
|
||||
@ -403,7 +403,7 @@ namespace Test
|
||||
|
||||
// 5.8
|
||||
TEST QuotedScalarIndicators() {
|
||||
YAML::Node doc = YAML::Parse(ex5_8);
|
||||
YAML::Node doc = YAML::Load(ex5_8);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["single"].as<std::string>() == "text");
|
||||
YAML_ASSERT(doc["double"].as<std::string>() == "text");
|
||||
@ -415,14 +415,14 @@ namespace Test
|
||||
|
||||
// 5.11
|
||||
TEST LineBreakCharacters() {
|
||||
YAML::Node doc = YAML::Parse(ex5_11);
|
||||
YAML::Node doc = YAML::Load(ex5_11);
|
||||
YAML_ASSERT(doc.as<std::string>() == "Line break (no glyph)\nLine break (glyphed)\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 5.12
|
||||
TEST TabsAndSpaces() {
|
||||
YAML::Node doc = YAML::Parse(ex5_12);
|
||||
YAML::Node doc = YAML::Load(ex5_12);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["quoted"].as<std::string>() == "Quoted\t");
|
||||
YAML_ASSERT(doc["block"].as<std::string>() ==
|
||||
@ -434,7 +434,7 @@ namespace Test
|
||||
|
||||
// 5.13
|
||||
TEST EscapedCharacters() {
|
||||
YAML::Node doc = YAML::Parse(ex5_13);
|
||||
YAML::Node doc = YAML::Load(ex5_13);
|
||||
YAML_ASSERT(doc.as<std::string>() == "Fun with \x5C \x22 \x07 \x08 \x1B \x0C \x0A \x0D \x09 \x0B " + std::string("\x00", 1) + " \x20 \xA0 \x85 \xe2\x80\xa8 \xe2\x80\xa9 A A A");
|
||||
return true;
|
||||
}
|
||||
@ -442,7 +442,7 @@ namespace Test
|
||||
// 5.14
|
||||
TEST InvalidEscapedCharacters() {
|
||||
try {
|
||||
YAML::Parse(ex5_14);
|
||||
YAML::Load(ex5_14);
|
||||
} catch(const YAML::ParserException& e) {
|
||||
YAML_ASSERT(e.msg == std::string(YAML::ErrorMsg::INVALID_ESCAPE) + "c");
|
||||
return true;
|
||||
@ -453,7 +453,7 @@ namespace Test
|
||||
|
||||
// 6.1
|
||||
TEST IndentationSpaces() {
|
||||
YAML::Node doc = YAML::Parse(ex6_1);
|
||||
YAML::Node doc = YAML::Load(ex6_1);
|
||||
YAML_ASSERT(doc.size() == 1);
|
||||
YAML_ASSERT(doc["Not indented"].size() == 2);
|
||||
YAML_ASSERT(doc["Not indented"]["By one space"].as<std::string>() == "By four\n spaces\n");
|
||||
@ -466,7 +466,7 @@ namespace Test
|
||||
|
||||
// 6.2
|
||||
TEST IndentationIndicators() {
|
||||
YAML::Node doc = YAML::Parse(ex6_2);
|
||||
YAML::Node doc = YAML::Load(ex6_2);
|
||||
YAML_ASSERT(doc.size() == 1);
|
||||
YAML_ASSERT(doc["a"].size() == 2);
|
||||
YAML_ASSERT(doc["a"][0].as<std::string>() == "b");
|
||||
@ -478,7 +478,7 @@ namespace Test
|
||||
|
||||
// 6.3
|
||||
TEST SeparationSpaces() {
|
||||
YAML::Node doc = YAML::Parse(ex6_3);
|
||||
YAML::Node doc = YAML::Load(ex6_3);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc[0].size() == 1);
|
||||
YAML_ASSERT(doc[0]["foo"].as<std::string>() == "bar");
|
||||
@ -490,7 +490,7 @@ namespace Test
|
||||
|
||||
// 6.4
|
||||
TEST LinePrefixes() {
|
||||
YAML::Node doc = YAML::Parse(ex6_4);
|
||||
YAML::Node doc = YAML::Load(ex6_4);
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc["plain"].as<std::string>() == "text lines");
|
||||
YAML_ASSERT(doc["quoted"].as<std::string>() == "text lines");
|
||||
@ -500,7 +500,7 @@ namespace Test
|
||||
|
||||
// 6.5
|
||||
TEST EmptyLines() {
|
||||
YAML::Node doc = YAML::Parse(ex6_5);
|
||||
YAML::Node doc = YAML::Load(ex6_5);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["Folding"].as<std::string>() == "Empty line\nas a line feed");
|
||||
YAML_ASSERT(doc["Chomping"].as<std::string>() == "Clipped empty lines\n");
|
||||
@ -509,28 +509,28 @@ namespace Test
|
||||
|
||||
// 6.6
|
||||
TEST LineFolding() {
|
||||
YAML::Node doc = YAML::Parse(ex6_6);
|
||||
YAML::Node doc = YAML::Load(ex6_6);
|
||||
YAML_ASSERT(doc.as<std::string>() == "trimmed\n\n\nas space");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 6.7
|
||||
TEST BlockFolding() {
|
||||
YAML::Node doc = YAML::Parse(ex6_7);
|
||||
YAML::Node doc = YAML::Load(ex6_7);
|
||||
YAML_ASSERT(doc.as<std::string>() == "foo \n\n\t bar\n\nbaz\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 6.8
|
||||
TEST FlowFolding() {
|
||||
YAML::Node doc = YAML::Parse(ex6_8);
|
||||
YAML::Node doc = YAML::Load(ex6_8);
|
||||
YAML_ASSERT(doc.as<std::string>() == " foo\nbar\nbaz ");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 6.9
|
||||
TEST SeparatedComment() {
|
||||
YAML::Node doc = YAML::Parse(ex6_9);
|
||||
YAML::Node doc = YAML::Load(ex6_9);
|
||||
YAML_ASSERT(doc.size() == 1);
|
||||
YAML_ASSERT(doc["key"].as<std::string>() == "value");
|
||||
return true;
|
||||
@ -538,14 +538,14 @@ namespace Test
|
||||
|
||||
// 6.10
|
||||
TEST CommentLines() {
|
||||
YAML::Node doc = YAML::Parse(ex6_10);
|
||||
YAML::Node doc = YAML::Load(ex6_10);
|
||||
YAML_ASSERT(doc.IsNull());
|
||||
return true;
|
||||
}
|
||||
|
||||
// 6.11
|
||||
TEST MultiLineComments() {
|
||||
YAML::Node doc = YAML::Parse(ex6_11);
|
||||
YAML::Node doc = YAML::Load(ex6_11);
|
||||
YAML_ASSERT(doc.size() == 1);
|
||||
YAML_ASSERT(doc["key"].as<std::string>() == "value");
|
||||
return true;
|
||||
@ -553,7 +553,7 @@ namespace Test
|
||||
|
||||
// 6.12
|
||||
TEST SeparationSpacesII() {
|
||||
YAML::Node doc = YAML::Parse(ex6_12);
|
||||
YAML::Node doc = YAML::Load(ex6_12);
|
||||
|
||||
std::map<std::string, std::string> sammy;
|
||||
sammy["first"] = "Sammy";
|
||||
@ -568,14 +568,14 @@ namespace Test
|
||||
|
||||
// 6.13
|
||||
TEST ReservedDirectives() {
|
||||
YAML::Node doc = YAML::Parse(ex6_13);
|
||||
YAML::Node doc = YAML::Load(ex6_13);
|
||||
YAML_ASSERT(doc.as<std::string>() == "foo");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 6.14
|
||||
TEST YAMLDirective() {
|
||||
YAML::Node doc = YAML::Parse(ex6_14);
|
||||
YAML::Node doc = YAML::Load(ex6_14);
|
||||
YAML_ASSERT(doc.as<std::string>() == "foo");
|
||||
return true;
|
||||
}
|
||||
@ -583,7 +583,7 @@ namespace Test
|
||||
// 6.15
|
||||
TEST InvalidRepeatedYAMLDirective() {
|
||||
try {
|
||||
YAML::Parse(ex6_15);
|
||||
YAML::Load(ex6_15);
|
||||
} catch(const YAML::ParserException& e) {
|
||||
YAML_ASSERT(e.msg == YAML::ErrorMsg::REPEATED_YAML_DIRECTIVE);
|
||||
return true;
|
||||
@ -594,7 +594,7 @@ namespace Test
|
||||
|
||||
// 6.16
|
||||
TEST TagDirective() {
|
||||
YAML::Node doc = YAML::Parse(ex6_16);
|
||||
YAML::Node doc = YAML::Load(ex6_16);
|
||||
YAML_ASSERT(doc.Tag() == "tag:yaml.org,2002:str");
|
||||
YAML_ASSERT(doc.as<std::string>() == "foo");
|
||||
return true;
|
||||
@ -603,7 +603,7 @@ namespace Test
|
||||
// 6.17
|
||||
TEST InvalidRepeatedTagDirective() {
|
||||
try {
|
||||
YAML::Parse(ex6_17);
|
||||
YAML::Load(ex6_17);
|
||||
} catch(const YAML::ParserException& e) {
|
||||
if(e.msg == YAML::ErrorMsg::REPEATED_TAG_DIRECTIVE)
|
||||
return true;
|
||||
@ -619,7 +619,7 @@ namespace Test
|
||||
|
||||
// 6.19
|
||||
TEST SecondaryTagHandle() {
|
||||
YAML::Node doc = YAML::Parse(ex6_19);
|
||||
YAML::Node doc = YAML::Load(ex6_19);
|
||||
YAML_ASSERT(doc.Tag() == "tag:example.com,2000:app/int");
|
||||
YAML_ASSERT(doc.as<std::string>() == "1 - 3");
|
||||
return true;
|
||||
@ -627,7 +627,7 @@ namespace Test
|
||||
|
||||
// 6.20
|
||||
TEST TagHandles() {
|
||||
YAML::Node doc = YAML::Parse(ex6_20);
|
||||
YAML::Node doc = YAML::Load(ex6_20);
|
||||
YAML_ASSERT(doc.Tag() == "tag:example.com,2000:app/foo");
|
||||
YAML_ASSERT(doc.as<std::string>() == "bar");
|
||||
return true;
|
||||
@ -638,7 +638,7 @@ namespace Test
|
||||
|
||||
// 6.22
|
||||
TEST GlobalTagPrefix() {
|
||||
YAML::Node doc = YAML::Parse(ex6_22);
|
||||
YAML::Node doc = YAML::Load(ex6_22);
|
||||
YAML_ASSERT(doc.size() == 1);
|
||||
YAML_ASSERT(doc[0].Tag() == "tag:example.com,2000:app/foo");
|
||||
YAML_ASSERT(doc[0].as<std::string>() == "bar");
|
||||
@ -647,7 +647,7 @@ namespace Test
|
||||
|
||||
// 6.23
|
||||
TEST NodeProperties() {
|
||||
YAML::Node doc = YAML::Parse(ex6_23);
|
||||
YAML::Node doc = YAML::Load(ex6_23);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
for(YAML::const_iterator it=doc.begin();it!=doc.end();++it) {
|
||||
if(it->first.as<std::string>() == "foo") {
|
||||
@ -665,7 +665,7 @@ namespace Test
|
||||
|
||||
// 6.24
|
||||
TEST VerbatimTags() {
|
||||
YAML::Node doc = YAML::Parse(ex6_24);
|
||||
YAML::Node doc = YAML::Load(ex6_24);
|
||||
YAML_ASSERT(doc.size() == 1);
|
||||
for(YAML::const_iterator it=doc.begin();it!=doc.end();++it) {
|
||||
YAML_ASSERT(it->first.Tag() == "tag:yaml.org,2002:str");
|
||||
@ -678,13 +678,13 @@ namespace Test
|
||||
|
||||
// 6.25
|
||||
TEST InvalidVerbatimTags() {
|
||||
YAML::Node doc = YAML::Parse(ex6_25);
|
||||
YAML::Node doc = YAML::Load(ex6_25);
|
||||
return " not implemented yet"; // TODO: check tags (but we probably will say these are valid, I think)
|
||||
}
|
||||
|
||||
// 6.26
|
||||
TEST TagShorthands() {
|
||||
YAML::Node doc = YAML::Parse(ex6_26);
|
||||
YAML::Node doc = YAML::Load(ex6_26);
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc[0].Tag() == "!local");
|
||||
YAML_ASSERT(doc[0].as<std::string>() == "foo");
|
||||
@ -699,7 +699,7 @@ namespace Test
|
||||
TEST InvalidTagShorthands() {
|
||||
bool threw = false;
|
||||
try {
|
||||
YAML::Parse(ex6_27a);
|
||||
YAML::Load(ex6_27a);
|
||||
} catch(const YAML::ParserException& e) {
|
||||
threw = true;
|
||||
if(e.msg != YAML::ErrorMsg::TAG_WITH_NO_SUFFIX)
|
||||
@ -709,13 +709,13 @@ namespace Test
|
||||
if(!threw)
|
||||
return " No exception was thrown for a tag with no suffix";
|
||||
|
||||
YAML::Parse(ex6_27b); // TODO: should we reject this one (since !h! is not declared)?
|
||||
YAML::Load(ex6_27b); // TODO: should we reject this one (since !h! is not declared)?
|
||||
return " not implemented yet";
|
||||
}
|
||||
|
||||
// 6.28
|
||||
TEST NonSpecificTags() {
|
||||
YAML::Node doc = YAML::Parse(ex6_28);
|
||||
YAML::Node doc = YAML::Load(ex6_28);
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc[0].as<std::string>() == "12"); // TODO: check tags. How?
|
||||
YAML_ASSERT(doc[1].as<int>() == 12);
|
||||
@ -725,7 +725,7 @@ namespace Test
|
||||
|
||||
// 6.29
|
||||
TEST NodeAnchors() {
|
||||
YAML::Node doc = YAML::Parse(ex6_29);
|
||||
YAML::Node doc = YAML::Load(ex6_29);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["First occurrence"].as<std::string>() == "Value");
|
||||
YAML_ASSERT(doc["Second occurrence"].as<std::string>() == "Value");
|
||||
@ -734,7 +734,7 @@ namespace Test
|
||||
|
||||
// 7.1
|
||||
TEST AliasNodes() {
|
||||
YAML::Node doc = YAML::Parse(ex7_1);
|
||||
YAML::Node doc = YAML::Load(ex7_1);
|
||||
YAML_ASSERT(doc.size() == 4);
|
||||
YAML_ASSERT(doc["First occurrence"].as<std::string>() == "Foo");
|
||||
YAML_ASSERT(doc["Second occurrence"].as<std::string>() == "Foo");
|
||||
@ -745,7 +745,7 @@ namespace Test
|
||||
|
||||
// 7.2
|
||||
TEST EmptyNodes() {
|
||||
YAML::Node doc = YAML::Parse(ex7_2);
|
||||
YAML::Node doc = YAML::Load(ex7_2);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
for(YAML::const_iterator it=doc.begin();it!=doc.end();++it) {
|
||||
if(it->first.as<std::string>() == "foo") {
|
||||
@ -762,7 +762,7 @@ namespace Test
|
||||
|
||||
// 7.3
|
||||
TEST CompletelyEmptyNodes() {
|
||||
YAML::Node doc = YAML::Parse(ex7_3);
|
||||
YAML::Node doc = YAML::Load(ex7_3);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["foo"].IsNull());
|
||||
YAML_ASSERT(doc[YAML::Null].as<std::string>() == "bar");
|
||||
@ -771,7 +771,7 @@ namespace Test
|
||||
|
||||
// 7.4
|
||||
TEST DoubleQuotedImplicitKeys() {
|
||||
YAML::Node doc = YAML::Parse(ex7_4);
|
||||
YAML::Node doc = YAML::Load(ex7_4);
|
||||
YAML_ASSERT(doc.size() == 1);
|
||||
YAML_ASSERT(doc["implicit block key"].size() == 1);
|
||||
YAML_ASSERT(doc["implicit block key"][0].size() == 1);
|
||||
@ -781,28 +781,28 @@ namespace Test
|
||||
|
||||
// 7.5
|
||||
TEST DoubleQuotedLineBreaks() {
|
||||
YAML::Node doc = YAML::Parse(ex7_5);
|
||||
YAML::Node doc = YAML::Load(ex7_5);
|
||||
YAML_ASSERT(doc.as<std::string>() == "folded to a space,\nto a line feed, or \t \tnon-content");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 7.6
|
||||
TEST DoubleQuotedLines() {
|
||||
YAML::Node doc = YAML::Parse(ex7_6);
|
||||
YAML::Node doc = YAML::Load(ex7_6);
|
||||
YAML_ASSERT(doc.as<std::string>() == " 1st non-empty\n2nd non-empty 3rd non-empty ");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 7.7
|
||||
TEST SingleQuotedCharacters() {
|
||||
YAML::Node doc = YAML::Parse(ex7_7);
|
||||
YAML::Node doc = YAML::Load(ex7_7);
|
||||
YAML_ASSERT(doc.as<std::string>() == "here's to \"quotes\"");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 7.8
|
||||
TEST SingleQuotedImplicitKeys() {
|
||||
YAML::Node doc = YAML::Parse(ex7_8);
|
||||
YAML::Node doc = YAML::Load(ex7_8);
|
||||
YAML_ASSERT(doc.size() == 1);
|
||||
YAML_ASSERT(doc["implicit block key"].size() == 1);
|
||||
YAML_ASSERT(doc["implicit block key"][0].size() == 1);
|
||||
@ -812,14 +812,14 @@ namespace Test
|
||||
|
||||
// 7.9
|
||||
TEST SingleQuotedLines() {
|
||||
YAML::Node doc = YAML::Parse(ex7_9);
|
||||
YAML::Node doc = YAML::Load(ex7_9);
|
||||
YAML_ASSERT(doc.as<std::string>() == " 1st non-empty\n2nd non-empty 3rd non-empty ");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 7.10
|
||||
TEST PlainCharacters() {
|
||||
YAML::Node doc = YAML::Parse(ex7_10);
|
||||
YAML::Node doc = YAML::Load(ex7_10);
|
||||
YAML_ASSERT(doc.size() == 6);
|
||||
YAML_ASSERT(doc[0].as<std::string>() == "::vector");
|
||||
YAML_ASSERT(doc[1].as<std::string>() == ": - ()");
|
||||
@ -837,7 +837,7 @@ namespace Test
|
||||
|
||||
// 7.11
|
||||
TEST PlainImplicitKeys() {
|
||||
YAML::Node doc = YAML::Parse(ex7_11);
|
||||
YAML::Node doc = YAML::Load(ex7_11);
|
||||
YAML_ASSERT(doc.size() == 1);
|
||||
YAML_ASSERT(doc["implicit block key"].size() == 1);
|
||||
YAML_ASSERT(doc["implicit block key"][0].size() == 1);
|
||||
@ -847,14 +847,14 @@ namespace Test
|
||||
|
||||
// 7.12
|
||||
TEST PlainLines() {
|
||||
YAML::Node doc = YAML::Parse(ex7_12);
|
||||
YAML::Node doc = YAML::Load(ex7_12);
|
||||
YAML_ASSERT(doc.as<std::string>() == "1st non-empty\n2nd non-empty 3rd non-empty");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 7.13
|
||||
TEST FlowSequence() {
|
||||
YAML::Node doc = YAML::Parse(ex7_13);
|
||||
YAML::Node doc = YAML::Load(ex7_13);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc[0].size() == 2);
|
||||
YAML_ASSERT(doc[0][0].as<std::string>() == "one");
|
||||
@ -867,7 +867,7 @@ namespace Test
|
||||
|
||||
// 7.14
|
||||
TEST FlowSequenceEntries() {
|
||||
YAML::Node doc = YAML::Parse(ex7_14);
|
||||
YAML::Node doc = YAML::Load(ex7_14);
|
||||
YAML_ASSERT(doc.size() == 5);
|
||||
YAML_ASSERT(doc[0].as<std::string>() == "double quoted");
|
||||
YAML_ASSERT(doc[1].as<std::string>() == "single quoted");
|
||||
@ -881,7 +881,7 @@ namespace Test
|
||||
|
||||
// 7.15
|
||||
TEST FlowMappings() {
|
||||
YAML::Node doc = YAML::Parse(ex7_15);
|
||||
YAML::Node doc = YAML::Load(ex7_15);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc[0].size() == 2);
|
||||
YAML_ASSERT(doc[0]["one"].as<std::string>() == "two");
|
||||
@ -894,7 +894,7 @@ namespace Test
|
||||
|
||||
// 7.16
|
||||
TEST FlowMappingEntries() {
|
||||
YAML::Node doc = YAML::Parse(ex7_16);
|
||||
YAML::Node doc = YAML::Load(ex7_16);
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc["explicit"].as<std::string>() == "entry");
|
||||
YAML_ASSERT(doc["implicit"].as<std::string>() == "entry");
|
||||
@ -904,7 +904,7 @@ namespace Test
|
||||
|
||||
// 7.17
|
||||
TEST FlowMappingSeparateValues() {
|
||||
YAML::Node doc = YAML::Parse(ex7_17);
|
||||
YAML::Node doc = YAML::Load(ex7_17);
|
||||
YAML_ASSERT(doc.size() == 4);
|
||||
YAML_ASSERT(doc["unquoted"].as<std::string>() == "separate");
|
||||
YAML_ASSERT(doc["http://foo.com"].IsNull());
|
||||
@ -915,7 +915,7 @@ namespace Test
|
||||
|
||||
// 7.18
|
||||
TEST FlowMappingAdjacentValues() {
|
||||
YAML::Node doc = YAML::Parse(ex7_18);
|
||||
YAML::Node doc = YAML::Load(ex7_18);
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc["adjacent"].as<std::string>() == "value");
|
||||
YAML_ASSERT(doc["readable"].as<std::string>() == "value");
|
||||
@ -925,7 +925,7 @@ namespace Test
|
||||
|
||||
// 7.19
|
||||
TEST SinglePairFlowMappings() {
|
||||
YAML::Node doc = YAML::Parse(ex7_19);
|
||||
YAML::Node doc = YAML::Load(ex7_19);
|
||||
YAML_ASSERT(doc.size() == 1);
|
||||
YAML_ASSERT(doc[0].size() == 1);
|
||||
YAML_ASSERT(doc[0]["foo"].as<std::string>() == "bar");
|
||||
@ -934,7 +934,7 @@ namespace Test
|
||||
|
||||
// 7.20
|
||||
TEST SinglePairExplicitEntry() {
|
||||
YAML::Node doc = YAML::Parse(ex7_20);
|
||||
YAML::Node doc = YAML::Load(ex7_20);
|
||||
YAML_ASSERT(doc.size() == 1);
|
||||
YAML_ASSERT(doc[0].size() == 1);
|
||||
YAML_ASSERT(doc[0]["foo bar"].as<std::string>() == "baz");
|
||||
@ -943,7 +943,7 @@ namespace Test
|
||||
|
||||
// 7.21
|
||||
TEST SinglePairImplicitEntries() {
|
||||
YAML::Node doc = YAML::Parse(ex7_21);
|
||||
YAML::Node doc = YAML::Load(ex7_21);
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc[0].size() == 1);
|
||||
YAML_ASSERT(doc[0][0].size() == 1);
|
||||
@ -963,7 +963,7 @@ namespace Test
|
||||
// 7.22
|
||||
TEST InvalidImplicitKeys() {
|
||||
try {
|
||||
YAML::Parse(ex7_22);
|
||||
YAML::Load(ex7_22);
|
||||
} catch(const YAML::Exception& e) {
|
||||
if(e.msg == YAML::ErrorMsg::END_OF_SEQ_FLOW)
|
||||
return true;
|
||||
@ -975,7 +975,7 @@ namespace Test
|
||||
|
||||
// 7.23
|
||||
TEST FlowContent() {
|
||||
YAML::Node doc = YAML::Parse(ex7_23);
|
||||
YAML::Node doc = YAML::Load(ex7_23);
|
||||
YAML_ASSERT(doc.size() == 5);
|
||||
YAML_ASSERT(doc[0].size() == 2);
|
||||
YAML_ASSERT(doc[0][0].as<std::string>() == "a");
|
||||
@ -990,7 +990,7 @@ namespace Test
|
||||
|
||||
// 7.24
|
||||
TEST FlowNodes() {
|
||||
YAML::Node doc = YAML::Parse(ex7_24);
|
||||
YAML::Node doc = YAML::Load(ex7_24);
|
||||
YAML_ASSERT(doc.size() == 5);
|
||||
YAML_ASSERT(doc[0].Tag() == "tag:yaml.org,2002:str");
|
||||
YAML_ASSERT(doc[0].as<std::string>() == "a");
|
||||
@ -1004,7 +1004,7 @@ namespace Test
|
||||
|
||||
// 8.1
|
||||
TEST BlockScalarHeader() {
|
||||
YAML::Node doc = YAML::Parse(ex8_1);
|
||||
YAML::Node doc = YAML::Load(ex8_1);
|
||||
YAML_ASSERT(doc.size() == 4);
|
||||
YAML_ASSERT(doc[0].as<std::string>() == "literal\n");
|
||||
YAML_ASSERT(doc[1].as<std::string>() == " folded\n");
|
||||
@ -1015,7 +1015,7 @@ namespace Test
|
||||
|
||||
// 8.2
|
||||
TEST BlockIndentationHeader() {
|
||||
YAML::Node doc = YAML::Parse(ex8_2);
|
||||
YAML::Node doc = YAML::Load(ex8_2);
|
||||
YAML_ASSERT(doc.size() == 4);
|
||||
YAML_ASSERT(doc[0].as<std::string>() == "detected\n");
|
||||
YAML_ASSERT(doc[1].as<std::string>() == "\n\n# detected\n");
|
||||
@ -1029,7 +1029,7 @@ namespace Test
|
||||
{
|
||||
bool threw = false;
|
||||
try {
|
||||
YAML::Parse(ex8_3a);
|
||||
YAML::Load(ex8_3a);
|
||||
} catch(const YAML::Exception& e) {
|
||||
if(e.msg != YAML::ErrorMsg::END_OF_SEQ)
|
||||
throw;
|
||||
@ -1044,7 +1044,7 @@ namespace Test
|
||||
{
|
||||
bool threw = false;
|
||||
try {
|
||||
YAML::Parse(ex8_3b);
|
||||
YAML::Load(ex8_3b);
|
||||
} catch(const YAML::Exception& e) {
|
||||
if(e.msg != YAML::ErrorMsg::END_OF_SEQ)
|
||||
throw;
|
||||
@ -1059,7 +1059,7 @@ namespace Test
|
||||
{
|
||||
bool threw = false;
|
||||
try {
|
||||
YAML::Parse(ex8_3c);
|
||||
YAML::Load(ex8_3c);
|
||||
} catch(const YAML::Exception& e) {
|
||||
if(e.msg != YAML::ErrorMsg::END_OF_SEQ)
|
||||
throw;
|
||||
@ -1076,7 +1076,7 @@ namespace Test
|
||||
|
||||
// 8.4
|
||||
TEST ChompingFinalLineBreak() {
|
||||
YAML::Node doc = YAML::Parse(ex8_4);
|
||||
YAML::Node doc = YAML::Load(ex8_4);
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc["strip"].as<std::string>() == "text");
|
||||
YAML_ASSERT(doc["clip"].as<std::string>() == "text\n");
|
||||
@ -1086,7 +1086,7 @@ namespace Test
|
||||
|
||||
// 8.5
|
||||
TEST ChompingTrailingLines() {
|
||||
YAML::Node doc = YAML::Parse(ex8_5);
|
||||
YAML::Node doc = YAML::Load(ex8_5);
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc["strip"].as<std::string>() == "# text");
|
||||
YAML_ASSERT(doc["clip"].as<std::string>() == "# text\n");
|
||||
@ -1096,7 +1096,7 @@ namespace Test
|
||||
|
||||
// 8.6
|
||||
TEST EmptyScalarChomping() {
|
||||
YAML::Node doc = YAML::Parse(ex8_6);
|
||||
YAML::Node doc = YAML::Load(ex8_6);
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc["strip"].as<std::string>() == "");
|
||||
YAML_ASSERT(doc["clip"].as<std::string>() == "");
|
||||
@ -1106,56 +1106,56 @@ namespace Test
|
||||
|
||||
// 8.7
|
||||
TEST LiteralScalar() {
|
||||
YAML::Node doc = YAML::Parse(ex8_7);
|
||||
YAML::Node doc = YAML::Load(ex8_7);
|
||||
YAML_ASSERT(doc.as<std::string>() == "literal\n\ttext\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 8.8
|
||||
TEST LiteralContent() {
|
||||
YAML::Node doc = YAML::Parse(ex8_8);
|
||||
YAML::Node doc = YAML::Load(ex8_8);
|
||||
YAML_ASSERT(doc.as<std::string>() == "\n\nliteral\n \n\ntext\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 8.9
|
||||
TEST FoldedScalar() {
|
||||
YAML::Node doc = YAML::Parse(ex8_9);
|
||||
YAML::Node doc = YAML::Load(ex8_9);
|
||||
YAML_ASSERT(doc.as<std::string>() == "folded text\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 8.10
|
||||
TEST FoldedLines() {
|
||||
YAML::Node doc = YAML::Parse(ex8_10);
|
||||
YAML::Node doc = YAML::Load(ex8_10);
|
||||
YAML_ASSERT(doc.as<std::string>() == "\nfolded line\nnext line\n * bullet\n\n * list\n * lines\n\nlast line\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 8.11
|
||||
TEST MoreIndentedLines() {
|
||||
YAML::Node doc = YAML::Parse(ex8_11);
|
||||
YAML::Node doc = YAML::Load(ex8_11);
|
||||
YAML_ASSERT(doc.as<std::string>() == "\nfolded line\nnext line\n * bullet\n\n * list\n * lines\n\nlast line\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 8.12
|
||||
TEST EmptySeparationLines() {
|
||||
YAML::Node doc = YAML::Parse(ex8_12);
|
||||
YAML::Node doc = YAML::Load(ex8_12);
|
||||
YAML_ASSERT(doc.as<std::string>() == "\nfolded line\nnext line\n * bullet\n\n * list\n * lines\n\nlast line\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 8.13
|
||||
TEST FinalEmptyLines() {
|
||||
YAML::Node doc = YAML::Parse(ex8_13);
|
||||
YAML::Node doc = YAML::Load(ex8_13);
|
||||
YAML_ASSERT(doc.as<std::string>() == "\nfolded line\nnext line\n * bullet\n\n * list\n * lines\n\nlast line\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 8.14
|
||||
TEST BlockSequence() {
|
||||
YAML::Node doc = YAML::Parse(ex8_14);
|
||||
YAML::Node doc = YAML::Load(ex8_14);
|
||||
YAML_ASSERT(doc.size() == 1);
|
||||
YAML_ASSERT(doc["block sequence"].size() == 2);
|
||||
YAML_ASSERT(doc["block sequence"][0].as<std::string>() == "one");
|
||||
@ -1166,7 +1166,7 @@ namespace Test
|
||||
|
||||
// 8.15
|
||||
TEST BlockSequenceEntryTypes() {
|
||||
YAML::Node doc = YAML::Parse(ex8_15);
|
||||
YAML::Node doc = YAML::Load(ex8_15);
|
||||
YAML_ASSERT(doc.size() == 4);
|
||||
YAML_ASSERT(doc[0].IsNull());
|
||||
YAML_ASSERT(doc[1].as<std::string>() == "block node\n");
|
||||
@ -1180,7 +1180,7 @@ namespace Test
|
||||
|
||||
// 8.16
|
||||
TEST BlockMappings() {
|
||||
YAML::Node doc = YAML::Parse(ex8_16);
|
||||
YAML::Node doc = YAML::Load(ex8_16);
|
||||
YAML_ASSERT(doc.size() == 1);
|
||||
YAML_ASSERT(doc["block mapping"].size() == 1);
|
||||
YAML_ASSERT(doc["block mapping"]["key"].as<std::string>() == "value");
|
||||
@ -1189,7 +1189,7 @@ namespace Test
|
||||
|
||||
// 8.17
|
||||
TEST ExplicitBlockMappingEntries() {
|
||||
YAML::Node doc = YAML::Parse(ex8_17);
|
||||
YAML::Node doc = YAML::Load(ex8_17);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["explicit key"].IsNull());
|
||||
YAML_ASSERT(doc["block key\n"].size() == 2);
|
||||
@ -1200,7 +1200,7 @@ namespace Test
|
||||
|
||||
// 8.18
|
||||
TEST ImplicitBlockMappingEntries() {
|
||||
YAML::Node doc = YAML::Parse(ex8_18);
|
||||
YAML::Node doc = YAML::Load(ex8_18);
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc["plain key"].as<std::string>() == "in-line value");
|
||||
YAML_ASSERT(doc[YAML::Null].IsNull());
|
||||
@ -1211,7 +1211,7 @@ namespace Test
|
||||
|
||||
// 8.19
|
||||
TEST CompactBlockMappings() {
|
||||
YAML::Node doc = YAML::Parse(ex8_19);
|
||||
YAML::Node doc = YAML::Load(ex8_19);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc[0].size() == 1);
|
||||
YAML_ASSERT(doc[0]["sun"].as<std::string>() == "yellow");
|
||||
@ -1225,7 +1225,7 @@ namespace Test
|
||||
|
||||
// 8.20
|
||||
TEST BlockNodeTypes() {
|
||||
YAML::Node doc = YAML::Parse(ex8_20);
|
||||
YAML::Node doc = YAML::Load(ex8_20);
|
||||
YAML_ASSERT(doc.size() == 3);
|
||||
YAML_ASSERT(doc[0].as<std::string>() == "flow in block");
|
||||
YAML_ASSERT(doc[1].as<std::string>() == "Block scalar\n");
|
||||
@ -1236,7 +1236,7 @@ namespace Test
|
||||
|
||||
// 8.21
|
||||
TEST BlockScalarNodes() {
|
||||
YAML::Node doc = YAML::Parse(ex8_21);
|
||||
YAML::Node doc = YAML::Load(ex8_21);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["literal"].as<std::string>() == "value"); // Note: I believe this is a bug in the YAML spec - it should be "value\n"
|
||||
YAML_ASSERT(doc["folded"].as<std::string>() == "value");
|
||||
@ -1246,7 +1246,7 @@ namespace Test
|
||||
|
||||
// 8.22
|
||||
TEST BlockCollectionNodes() {
|
||||
YAML::Node doc = YAML::Parse(ex8_22);
|
||||
YAML::Node doc = YAML::Load(ex8_22);
|
||||
YAML_ASSERT(doc.size() == 2);
|
||||
YAML_ASSERT(doc["sequence"].size() == 2);
|
||||
YAML_ASSERT(doc["sequence"][0].as<std::string>() == "entry");
|
||||
|
||||
@ -46,7 +46,7 @@ void parse(std::istream& input)
|
||||
std::cout << emitter.c_str() << "\n";
|
||||
}
|
||||
#else
|
||||
YAML::Node doc = YAML::Parse(input);
|
||||
YAML::Node doc = YAML::Load(input);
|
||||
std::cout << doc << "\n";
|
||||
#endif
|
||||
} catch(const YAML::Exception& e) {
|
||||
|
||||
Loading…
Reference in New Issue
Block a user