peisongxiao/yaml-cpp
1
0
Fork 0
mirror of https://github.com/jbeder/yaml-cpp.git synced 2025-09-09 04:41:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add flow/block style setting on Nodes

Browse Source
This commit is contained in:
Jesse Beder
2015-01-24 13:11:43 -06:00
parent 9880b608b9
commit 0c280724e9
13 changed files with 252 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
test/integration/load_node_test.cpp
View File

@@ -5,12 +5,12 @@
namespace YAML {
namespace {
TEST(LoadNodeTest, Reassign) {
YAML::Node node = YAML::Load("foo");
node = YAML::Node();
Node node = Load("foo");
node = Node();
}
TEST(LoadNodeTest, FallbackValues) {
YAML::Node node = YAML::Load("foo: bar\nx: 2");
Node node = Load("foo: bar\nx: 2");
EXPECT_EQ("bar", node["foo"].as<std::string>());
EXPECT_EQ("bar", node["foo"].as<std::string>("hello"));
EXPECT_EQ("hello", node["baz"].as<std::string>("hello"));
@@ -20,10 +20,10 @@ TEST(LoadNodeTest, FallbackValues) {
}
TEST(LoadNodeTest, NumericConversion) {
YAML::Node node = YAML::Load("[1.5, 1, .nan, .inf, -.inf, 0x15, 015]");
Node node = Load("[1.5, 1, .nan, .inf, -.inf, 0x15, 015]");
EXPECT_EQ(1.5f, node[0].as<float>());
EXPECT_EQ(1.5, node[0].as<double>());
EXPECT_THROW(node[0].as<int>(), YAML::TypedBadConversion<int>);
EXPECT_THROW(node[0].as<int>(), TypedBadConversion<int>);
EXPECT_EQ(1, node[1].as<int>());
EXPECT_EQ(1.0f, node[1].as<float>());
EXPECT_NE(node[2].as<float>(), node[2].as<float>());
@@ -34,7 +34,7 @@ TEST(LoadNodeTest, NumericConversion) {
}
TEST(LoadNodeTest, Binary) {
YAML::Node node = YAML::Load(
Node node = Load(
"[!!binary \"SGVsbG8sIFdvcmxkIQ==\", !!binary "
"\"TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieS"
"B0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIG"
@@ -42,25 +42,24 @@ TEST(LoadNodeTest, Binary) {
"B0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZG"
"dlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS"
"4K\"]");
EXPECT_EQ(
YAML::Binary(reinterpret_cast<const unsigned char*>("Hello, World!"), 13),
node[0].as<YAML::Binary>());
EXPECT_EQ(YAML::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),
node[1].as<YAML::Binary>());
EXPECT_EQ(Binary(reinterpret_cast<const unsigned char*>("Hello, World!"), 13),
node[0].as<Binary>());
EXPECT_EQ(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),
node[1].as<Binary>());
}
TEST(LoadNodeTest, IterateSequence) {
YAML::Node node = YAML::Load("[1, 3, 5, 7]");
Node node = Load("[1, 3, 5, 7]");
int seq[] = {1, 3, 5, 7};
int i = 0;
for (YAML::const_iterator it = node.begin(); it != node.end(); ++it) {
for (const_iterator it = node.begin(); it != node.end(); ++it) {
EXPECT_TRUE(i < 4);
int x = seq[i++];
EXPECT_EQ(x, it->as<int>());
@@ -69,9 +68,9 @@ TEST(LoadNodeTest, IterateSequence) {
}
TEST(LoadNodeTest, IterateMap) {
YAML::Node node = YAML::Load("{a: A, b: B, c: C}");
Node node = Load("{a: A, b: B, c: C}");
int i = 0;
for (YAML::const_iterator it = node.begin(); it != node.end(); ++it) {
for (const_iterator it = node.begin(); it != node.end(); ++it) {
EXPECT_TRUE(i < 3);
i++;
EXPECT_EQ(it->second.as<char>(), it->first.as<char>() + 'A' - 'a');
@@ -81,36 +80,36 @@ TEST(LoadNodeTest, IterateMap) {
#ifdef BOOST_FOREACH
TEST(LoadNodeTest, ForEach) {
YAML::Node node = YAML::Load("[1, 3, 5, 7]");
Node node = Load("[1, 3, 5, 7]");
int seq[] = {1, 3, 5, 7};
int i = 0;
BOOST_FOREACH(const YAML::Node & item, node) {
BOOST_FOREACH (const Node& item, node) {
int x = seq[i++];
EXPECT_EQ(x, item.as<int>());
}
}
TEST(LoadNodeTest, ForEachMap) {
YAML::Node node = YAML::Load("{a: A, b: B, c: C}");
BOOST_FOREACH(const YAML::const_iterator::value_type & p, node) {
Node node = Load("{a: A, b: B, c: C}");
BOOST_FOREACH (const const_iterator::value_type& p, node) {
EXPECT_EQ(p.second.as<char>(), p.first.as<char>() + 'A' - 'a');
}
}
#endif
TEST(LoadNodeTest, CloneScalar) {
YAML::Node node = YAML::Load("!foo monkey");
YAML::Node clone = Clone(node);
Node node = Load("!foo monkey");
Node clone = Clone(node);
EXPECT_FALSE(clone == node);
EXPECT_EQ(clone.as<std::string>(), node.as<std::string>());
EXPECT_EQ(clone.Tag(), node.Tag());
}
TEST(LoadNodeTest, CloneSeq) {
YAML::Node node = YAML::Load("[1, 3, 5, 7]");
YAML::Node clone = Clone(node);
Node node = Load("[1, 3, 5, 7]");
Node clone = Clone(node);
EXPECT_FALSE(clone == node);
EXPECT_EQ(YAML::NodeType::Sequence, clone.Type());
EXPECT_EQ(NodeType::Sequence, clone.Type());
EXPECT_EQ(clone.size(), node.size());
for (std::size_t i = 0; i < node.size(); i++) {
EXPECT_EQ(clone[i].as<int>(), node[i].as<int>());
@@ -118,34 +117,34 @@ TEST(LoadNodeTest, CloneSeq) {
}
TEST(LoadNodeTest, CloneMap) {
YAML::Node node = YAML::Load("{foo: bar}");
YAML::Node clone = Clone(node);
Node node = Load("{foo: bar}");
Node clone = Clone(node);
EXPECT_FALSE(clone == node);
EXPECT_EQ(YAML::NodeType::Map, clone.Type());
EXPECT_EQ(NodeType::Map, clone.Type());
EXPECT_EQ(clone.size(), node.size());
EXPECT_EQ(clone["foo"].as<std::string>(), node["foo"].as<std::string>());
}
TEST(LoadNodeTest, CloneAlias) {
YAML::Node node = YAML::Load("&foo [*foo]");
YAML::Node clone = Clone(node);
Node node = Load("&foo [*foo]");
Node clone = Clone(node);
EXPECT_FALSE(clone == node);
EXPECT_EQ(YAML::NodeType::Sequence, clone.Type());
EXPECT_EQ(NodeType::Sequence, clone.Type());
EXPECT_EQ(clone.size(), node.size());
EXPECT_EQ(clone[0], clone);
}
TEST(LoadNodeTest, ForceInsertIntoMap) {
YAML::Node node;
Node node;
node["a"] = "b";
node.force_insert("x", "y");
node.force_insert("a", 5);
EXPECT_EQ(3, node.size());
EXPECT_EQ(YAML::NodeType::Map, node.Type());
EXPECT_EQ(NodeType::Map, node.Type());
bool ab = false;
bool a5 = false;
bool xy = false;
for (YAML::const_iterator it = node.begin(); it != node.end(); ++it) {
for (const_iterator it = node.begin(); it != node.end(); ++it) {
if (it->first.as<std::string>() == "a") {
if (it->second.as<std::string>() == "b")
ab = true;
@@ -161,9 +160,9 @@ TEST(LoadNodeTest, ForceInsertIntoMap) {
}
TEST(LoadNodeTest, ResetNode) {
YAML::Node node = YAML::Load("[1, 2, 3]");
Node node = Load("[1, 2, 3]");
EXPECT_TRUE(!node.IsNull());
YAML::Node other = node;
Node other = node;
node.reset();
EXPECT_TRUE(node.IsNull());
EXPECT_TRUE(!other.IsNull());
@@ -173,19 +172,26 @@ TEST(LoadNodeTest, ResetNode) {
}
TEST(LoadNodeTest, DereferenceIteratorError) {
YAML::Node node = YAML::Load("[{a: b}, 1, 2]");
EXPECT_THROW(node.begin()->first.as<int>(), YAML::InvalidNode);
Node node = Load("[{a: b}, 1, 2]");
EXPECT_THROW(node.begin()->first.as<int>(), InvalidNode);
EXPECT_EQ(true, (*node.begin()).IsMap());
EXPECT_EQ(true, node.begin()->IsMap());
EXPECT_THROW((*node.begin()->begin()).IsDefined(), YAML::InvalidNode);
EXPECT_THROW(node.begin()->begin()->IsDefined(), YAML::InvalidNode);
EXPECT_THROW((*node.begin()->begin()).IsDefined(), InvalidNode);
EXPECT_THROW(node.begin()->begin()->IsDefined(), InvalidNode);
}
TEST(NodeTest, EmitEmptyNode) {
YAML::Node node;
YAML::Emitter emitter;
Node node;
Emitter emitter;
emitter << node;
EXPECT_EQ("", std::string(emitter.c_str()));
}
TEST(NodeTest, ParseNodeStyle) {
EXPECT_EQ(EmitterStyle::Flow, Load("[1, 2, 3]").Style());
EXPECT_EQ(EmitterStyle::Flow, Load("{foo: bar}").Style());
EXPECT_EQ(EmitterStyle::Block, Load("- foo\n- bar").Style());
EXPECT_EQ(EmitterStyle::Block, Load("foo: bar").Style());
}
}
}