Skip to content

GitLab

Commit ad0a3311 authored by Jesse Beder's avatar Jesse Beder
Browse files

Convert node tests to gtest

parent 33424ecb
Hide whitespace changes
Inline Side-by-side
Showing with 439 additions and 712 deletions
test/integration/load_node_test.cpp 0 → 100644
View file @ ad0a3311
#include "yaml-cpp/yaml.h" // IWYU pragma: keep
#include "gtest/gtest.h"
namespace YAML {
namespace {
TEST(LoadNodeTest, Reassign) {
YAML::Node node = YAML::Load("foo");
node = YAML::Node();
}
TEST(LoadNodeTest, FallbackValues) {
YAML::Node node = YAML::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"));
EXPECT_EQ(2, node["x"].as<int>());
EXPECT_EQ(2, node["x"].as<int>(5));
EXPECT_EQ(5, node["y"].as<int>(5));
}
TEST(LoadNodeTest, NumericConversion) {
YAML::Node node = YAML::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_EQ(1, node[1].as<int>());
EXPECT_EQ(1.0f, node[1].as<float>());
EXPECT_NE(node[2].as<float>(), node[2].as<float>());
EXPECT_EQ(std::numeric_limits<float>::infinity(), node[3].as<float>());
EXPECT_EQ(-std::numeric_limits<float>::infinity(), node[4].as<float>());
EXPECT_EQ(21, node[5].as<int>());
EXPECT_EQ(13, node[6].as<int>());
}
TEST(LoadNodeTest, Binary) {
YAML::Node node = YAML::Load(
"[!!binary \"SGVsbG8sIFdvcmxkIQ==\", !!binary "
"\"TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieS"
"B0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIG"
"x1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbi"
"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>());
}
TEST(LoadNodeTest, IterateSequence) {
YAML::Node node = YAML::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) {
EXPECT_TRUE(i < 4);
int x = seq[i++];
EXPECT_EQ(x, it->as<int>());
}
EXPECT_EQ(4, i);
}
TEST(LoadNodeTest, IterateMap) {
YAML::Node node = YAML::Load("{a: A, b: B, c: C}");
int i = 0;
for (YAML::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');
}
EXPECT_EQ(3, i);
}
#ifdef BOOST_FOREACH
TEST(LoadNodeTest, ForEach) {
YAML::Node node = YAML::Load("[1, 3, 5, 7]");
int seq[] = {1, 3, 5, 7};
int i = 0;
BOOST_FOREACH(const YAML::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) {
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);
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);
EXPECT_FALSE(clone == node);
EXPECT_EQ(YAML::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>());
}
}
TEST(LoadNodeTest, CloneMap) {
YAML::Node node = YAML::Load("{foo: bar}");
YAML::Node clone = Clone(node);
EXPECT_FALSE(clone == node);
EXPECT_EQ(YAML::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);
EXPECT_FALSE(clone == node);
EXPECT_EQ(YAML::NodeType::Sequence, clone.Type());
EXPECT_EQ(clone.size(), node.size());
EXPECT_EQ(clone[0], clone);
}
TEST(LoadNodeTest, ForceInsertIntoMap) {
YAML::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());
bool ab = false;
bool a5 = false;
bool xy = false;
for (YAML::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;
else if (it->second.as<std::string>() == "5")
a5 = true;
} else if (it->first.as<std::string>() == "x" &&
it->second.as<std::string>() == "y")
xy = true;
}
EXPECT_TRUE(ab);
EXPECT_TRUE(a5);
EXPECT_TRUE(xy);
}
TEST(LoadNodeTest, ResetNode) {
YAML::Node node = YAML::Load("[1, 2, 3]");
EXPECT_TRUE(!node.IsNull());
YAML::Node other = node;
node.reset();
EXPECT_TRUE(node.IsNull());
EXPECT_TRUE(!other.IsNull());
node.reset(other);
EXPECT_TRUE(!node.IsNull());
EXPECT_EQ(node, other);
}
TEST(LoadNodeTest, DereferenceIteratorError) {
YAML::Node node = YAML::Load("[{a: b}, 1, 2]");
EXPECT_THROW(node.begin()->first.as<int>(), YAML::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);
}
TEST(NodeTest, EmitEmptyNode) {
YAML::Node node;
YAML::Emitter emitter;
emitter << node;
EXPECT_EQ("", std::string(emitter.c_str()));
}
}
}
test/main.cpp
View file @ ad0a3311
#include "tests.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
int main(int argc, char** argv) { int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv); ::testing::InitGoogleTest(&argc, argv);
Test::RunAll();
return RUN_ALL_TESTS(); return RUN_ALL_TESTS();
} }
test/new-api/nodetests.cpp deleted 100644 → 0
View file @ 33424ecb
#include <boost/version.hpp>
#include <iostream>
#include "nodetests.h"
#include "yaml-cpp/yaml.h" // IWYU pragma: keep
namespace YAML {
class InvalidNode;
template <typename T> class TypedBadConversion;
} // namespace YAML
#if BOOST_VERSION >= 103400
#include <boost/foreach.hpp>
#endif
namespace {
struct TEST {
TEST() : ok(false) {}
TEST(bool ok_) : ok(ok_) {}
TEST(const char* error_) : ok(false), error(error_) {}
TEST(const std::string& error_) : ok(false), error(error_) {}
bool ok;
std::string error;
};
}
#define YAML_ASSERT(cond) \
do { \
if (!(cond)) \
return " Assert failed: " #cond; \
} while (false)
#define YAML_ASSERT_THROWS(cond, exc) \
do { \
try { \
(cond); \
return " Expression did not throw: " #cond; \
} \
catch (const exc&) { \
} \
catch (const std::runtime_error& e) { \
std::stringstream stream; \
stream << " Expression threw runtime error ther than " #exc \
":\n " #cond "\n " << e.what(); \
return stream.str(); \
} \
catch (...) { \
return " Expression threw unknown exception, other than " #exc \
":\n " #cond; \
} \
} while (false)
namespace Test {
namespace Node {
TEST SimpleScalar() {
YAML::Node node = YAML::Node("Hello, World!");
YAML_ASSERT(node.IsScalar());
YAML_ASSERT(node.as<std::string>() == "Hello, World!");
return true;
}
TEST IntScalar() {
YAML::Node node = YAML::Node(15);
YAML_ASSERT(node.IsScalar());
YAML_ASSERT(node.as<int>() == 15);
return true;
}
TEST SimpleAppendSequence() {
YAML::Node node;
node.push_back(10);
node.push_back("foo");
node.push_back("monkey");
YAML_ASSERT(node.IsSequence());
YAML_ASSERT(node.size() == 3);
YAML_ASSERT(node[0].as<int>() == 10);
YAML_ASSERT(node[1].as<std::string>() == "foo");
YAML_ASSERT(node[2].as<std::string>() == "monkey");
YAML_ASSERT(node.IsSequence());
return true;
}
TEST SimpleAssignSequence() {
YAML::Node node;
node[0] = 10;
node[1] = "foo";
node[2] = "monkey";
YAML_ASSERT(node.IsSequence());
YAML_ASSERT(node.size() == 3);
YAML_ASSERT(node[0].as<int>() == 10);
YAML_ASSERT(node[1].as<std::string>() == "foo");
YAML_ASSERT(node[2].as<std::string>() == "monkey");
YAML_ASSERT(node.IsSequence());
return true;
}
TEST SimpleMap() {
YAML::Node node;
node["key"] = "value";
YAML_ASSERT(node.IsMap());
YAML_ASSERT(node["key"].as<std::string>() == "value");
YAML_ASSERT(node.size() == 1);
return true;
}
TEST MapWithUndefinedValues() {
YAML::Node node;
node["key"] = "value";
node["undefined"];
YAML_ASSERT(node.IsMap());
YAML_ASSERT(node["key"].as<std::string>() == "value");
YAML_ASSERT(node.size() == 1);
node["undefined"] = "monkey";
YAML_ASSERT(node["undefined"].as<std::string>() == "monkey");
YAML_ASSERT(node.size() == 2);
return true;
}
TEST MapIteratorWithUndefinedValues() {
YAML::Node node;
node["key"] = "value";
node["undefined"];
std::size_t count = 0;
for (YAML::const_iterator it = node.begin(); it != node.end(); ++it)
count++;
YAML_ASSERT(count == 1);
return true;
}
TEST SimpleSubkeys() {
YAML::Node node;
node["device"]["udid"] = "12345";
node["device"]["name"] = "iPhone";
node["device"]["os"] = "4.0";
node["username"] = "monkey";
YAML_ASSERT(node["device"]["udid"].as<std::string>() == "12345");
YAML_ASSERT(node["device"]["name"].as<std::string>() == "iPhone");
YAML_ASSERT(node["device"]["os"].as<std::string>() == "4.0");
YAML_ASSERT(node["username"].as<std::string>() == "monkey");
return true;
}
TEST StdVector() {
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);
YAML::Node node;
node["primes"] = primes;
YAML_ASSERT(node["primes"].as<std::vector<int> >() == primes);
return true;
}
TEST StdList() {
std::list<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);
YAML::Node node;
node["primes"] = primes;
YAML_ASSERT(node["primes"].as<std::list<int> >() == primes);
return true;
}
TEST StdMap() {
std::map<int, int> squares;
squares[0] = 0;
squares[1] = 1;
squares[2] = 4;
squares[3] = 9;
squares[4] = 16;
YAML::Node node;
node["squares"] = squares;
YAML_ASSERT((node["squares"].as<std::map<int, int> >() == squares));
return true;
}
TEST StdPair() {
std::pair<int, std::string> p;
p.first = 5;
p.second = "five";
YAML::Node node;
node["pair"] = p;
YAML_ASSERT((node["pair"].as<std::pair<int, std::string> >() == p));
return true;
}
TEST SimpleAlias() {
YAML::Node node;
node["foo"] = "value";
node["bar"] = node["foo"];
YAML_ASSERT(node["foo"].as<std::string>() == "value");
YAML_ASSERT(node["bar"].as<std::string>() == "value");
YAML_ASSERT(node["foo"] == node["bar"]);
YAML_ASSERT(node.size() == 2);
return true;
}
TEST AliasAsKey() {
YAML::Node node;
node["foo"] = "value";
YAML::Node value = node["foo"];
node[value] = "foo";
YAML_ASSERT(node["foo"].as<std::string>() == "value");
YAML_ASSERT(node[value].as<std::string>() == "foo");
YAML_ASSERT(node["value"].as<std::string>() == "foo");
YAML_ASSERT(node.size() == 2);
return true;
}
TEST SelfReferenceSequence() {
YAML::Node node;
node[0] = node;
YAML_ASSERT(node.IsSequence());
YAML_ASSERT(node.size() == 1);
YAML_ASSERT(node[0] == node);
YAML_ASSERT(node[0][0] == node);
YAML_ASSERT(node[0][0] == node[0]);
return true;
}
TEST ValueSelfReferenceMap() {
YAML::Node node;
node["key"] = node;
YAML_ASSERT(node.IsMap());
YAML_ASSERT(node.size() == 1);
YAML_ASSERT(node["key"] == node);
YAML_ASSERT(node["key"]["key"] == node);
YAML_ASSERT(node["key"]["key"] == node["key"]);
return true;
}
TEST KeySelfReferenceMap() {
YAML::Node node;
node[node] = "value";
YAML_ASSERT(node.IsMap());
YAML_ASSERT(node.size() == 1);
YAML_ASSERT(node[node].as<std::string>() == "value");
return true;
}
TEST SelfReferenceMap() {
YAML::Node node;
node[node] = node;
YAML_ASSERT(node.IsMap());
YAML_ASSERT(node.size() == 1);
YAML_ASSERT(node[node] == node);
YAML_ASSERT(node[node][node] == node);
YAML_ASSERT(node[node][node] == node[node]);
return true;
}
TEST TempMapVariable() {
YAML::Node node;
YAML::Node tmp = node["key"];
tmp = "value";
YAML_ASSERT(node.IsMap());
YAML_ASSERT(node.size() == 1);
YAML_ASSERT(node["key"].as<std::string>() == "value");
return true;
}
TEST TempMapVariableAlias() {
YAML::Node node;
YAML::Node tmp = node["key"];
tmp = node["other"];
node["other"] = "value";
YAML_ASSERT(node.IsMap());
YAML_ASSERT(node.size() == 2);
YAML_ASSERT(node["key"].as<std::string>() == "value");
YAML_ASSERT(node["other"].as<std::string>() == "value");
YAML_ASSERT(node["other"] == node["key"]);
return true;
}
TEST Bool() {
YAML::Node node;
node[true] = false;
YAML_ASSERT(node.IsMap());
YAML_ASSERT(node[true].as<bool>() == false);
return true;
}
TEST AutoBoolConversion() {
YAML::Node node;
node["foo"] = "bar";
YAML_ASSERT(static_cast<bool>(node["foo"]));
YAML_ASSERT(!node["monkey"]);
YAML_ASSERT(!!node["foo"]);
return true;
}
TEST Reassign() {
YAML::Node node = YAML::Load("foo");
node = YAML::Node();
return true;
}
TEST FallbackValues() {
YAML::Node node = YAML::Load("foo: bar\nx: 2");
YAML_ASSERT(node["foo"].as<std::string>() == "bar");
YAML_ASSERT(node["foo"].as<std::string>("hello") == "bar");
YAML_ASSERT(node["baz"].as<std::string>("hello") == "hello");
YAML_ASSERT(node["x"].as<int>() == 2);
YAML_ASSERT(node["x"].as<int>(5) == 2);
YAML_ASSERT(node["y"].as<int>(5) == 5);
return true;
}
TEST NumericConversion() {
YAML::Node node = YAML::Load("[1.5, 1, .nan, .inf, -.inf, 0x15, 015]");
YAML_ASSERT(node[0].as<float>() == 1.5f);
YAML_ASSERT(node[0].as<double>() == 1.5);
YAML_ASSERT_THROWS(node[0].as<int>(), YAML::TypedBadConversion<int>);
YAML_ASSERT(node[1].as<int>() == 1);
YAML_ASSERT(node[1].as<float>() == 1.0f);
YAML_ASSERT(node[2].as<float>() != node[2].as<float>());
YAML_ASSERT(node[3].as<float>() == std::numeric_limits<float>::infinity());
YAML_ASSERT(node[4].as<float>() == -std::numeric_limits<float>::infinity());
YAML_ASSERT(node[5].as<int>() == 21);
YAML_ASSERT(node[6].as<int>() == 13);
return true;
}
TEST Binary() {
YAML::Node node = YAML::Load(
"[!!binary \"SGVsbG8sIFdvcmxkIQ==\", !!binary "
"\"TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieS"
"B0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIG"
"x1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbi"
"B0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZG"
"dlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS"
"4K\"]");
YAML_ASSERT(node[0].as<YAML::Binary>() ==
YAML::Binary(
reinterpret_cast<const unsigned char*>("Hello, World!"), 13));
YAML_ASSERT(node[1].as<YAML::Binary>() ==
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));
return true;
}
TEST IterateSequence() {
YAML::Node node = YAML::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) {
YAML_ASSERT(i < 4);
int x = seq[i++];
YAML_ASSERT(it->as<int>() == x);
}
YAML_ASSERT(i == 4);
return true;
}
TEST IterateMap() {
YAML::Node node = YAML::Load("{a: A, b: B, c: C}");
int i = 0;
for (YAML::const_iterator it = node.begin(); it != node.end(); ++it) {
YAML_ASSERT(i < 3);
i++;
YAML_ASSERT(it->first.as<char>() + 'A' - 'a' == it->second.as<char>());
}
YAML_ASSERT(i == 3);
return true;
}
#ifdef BOOST_FOREACH
TEST ForEach() {
YAML::Node node = YAML::Load("[1, 3, 5, 7]");
int seq[] = {1, 3, 5, 7};
int i = 0;
BOOST_FOREACH(const YAML::Node & item, node) {
int x = seq[i++];
YAML_ASSERT(item.as<int>() == x);
}
return true;
}
TEST ForEachMap() {
YAML::Node node = YAML::Load("{a: A, b: B, c: C}");
BOOST_FOREACH(const YAML::const_iterator::value_type & p, node) {
YAML_ASSERT(p.first.as<char>() + 'A' - 'a' == p.second.as<char>());
}
return true;
}
#endif
TEST CloneScalar() {
YAML::Node node = YAML::Load("!foo monkey");
YAML::Node clone = Clone(node);
YAML_ASSERT(!(node == clone));
YAML_ASSERT(node.as<std::string>() == clone.as<std::string>());
YAML_ASSERT(node.Tag() == clone.Tag());
return true;
}
TEST CloneSeq() {
YAML::Node node = YAML::Load("[1, 3, 5, 7]");
YAML::Node clone = Clone(node);
YAML_ASSERT(!(node == clone));
YAML_ASSERT(clone.Type() == YAML::NodeType::Sequence);
YAML_ASSERT(node.size() == clone.size());
for (std::size_t i = 0; i < node.size(); i++)
YAML_ASSERT(node[i].as<int>() == clone[i].as<int>());
return true;
}
TEST CloneMap() {
YAML::Node node = YAML::Load("{foo: bar}");
YAML::Node clone = Clone(node);
YAML_ASSERT(!(node == clone));
YAML_ASSERT(clone.Type() == YAML::NodeType::Map);
YAML_ASSERT(node.size() == clone.size());
YAML_ASSERT(node["foo"].as<std::string>() == clone["foo"].as<std::string>());
return true;
}
TEST CloneAlias() {
YAML::Node node = YAML::Load("&foo [*foo]");
YAML::Node clone = Clone(node);
YAML_ASSERT(!(node == clone));
YAML_ASSERT(clone.Type() == YAML::NodeType::Sequence);
YAML_ASSERT(node.size() == clone.size());
YAML_ASSERT(clone == clone[0]);
return true;
}
TEST ForceInsertIntoMap() {
YAML::Node node;
node["a"] = "b";
node.force_insert("x", "y");
node.force_insert("a", 5);
YAML_ASSERT(node.size() == 3);
YAML_ASSERT(node.Type() == YAML::NodeType::Map);
bool ab = false;
bool a5 = false;
bool xy = false;
for (YAML::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;
else if (it->second.as<std::string>() == "5")
a5 = true;
} else if (it->first.as<std::string>() == "x" &&
it->second.as<std::string>() == "y")
xy = true;
}
YAML_ASSERT(ab);
YAML_ASSERT(a5);
YAML_ASSERT(xy);
return true;
}
TEST ResetNode() {
YAML::Node node = YAML::Load("[1, 2, 3]");
YAML_ASSERT(!node.IsNull());
YAML::Node other = node;
node.reset();
YAML_ASSERT(node.IsNull());
YAML_ASSERT(!other.IsNull());
node.reset(other);
YAML_ASSERT(!node.IsNull());
YAML_ASSERT(other == node);
return true;
}
TEST DereferenceIteratorError() {
YAML::Node node = YAML::Load("[{a: b}, 1, 2]");
YAML_ASSERT_THROWS(node.begin()->first.as<int>(), YAML::InvalidNode);
YAML_ASSERT((*node.begin()).IsMap() == true);
YAML_ASSERT(node.begin()->IsMap() == true);
YAML_ASSERT_THROWS((*node.begin()->begin()).IsDefined(), YAML::InvalidNode);
YAML_ASSERT_THROWS(node.begin()->begin()->IsDefined(), YAML::InvalidNode);
return true;
}
TEST FloatingPrecision() {
const double x = 0.123456789;
YAML::Node node = YAML::Node(x);
YAML_ASSERT(node.as<double>() == x);
return true;
}
TEST EmitEmptyNode() {
YAML::Node node;
YAML::Emitter emitter;
emitter << node;
YAML_ASSERT(std::string(emitter.c_str()) == "");
return true;
}
TEST SpaceChar() {
YAML::Node node = YAML::Node(' ');
YAML_ASSERT(node.as<char>() == ' ');
return true;
}
}
void RunNodeTest(TEST (*test)(), const std::string& name, int& passed,
int& total) {
TEST ret;
try {
ret = test();
}
catch (const std::exception& e) {
ret.ok = false;
ret.error = e.what();
}
if (ret.ok) {
passed++;
} else {
std::cout << "Node test failed: " << name << "\n";
if (ret.error != "")
std::cout << ret.error << "\n";
}
total++;
}
bool RunNodeTests() {
int passed = 0;
int total = 0;
RunNodeTest(&Node::SimpleScalar, "simple scalar", passed, total);
RunNodeTest(&Node::IntScalar, "int scalar", passed, total);
RunNodeTest(&Node::SimpleAppendSequence, "simple append sequence", passed,
total);
RunNodeTest(&Node::SimpleAssignSequence, "simple assign sequence", passed,
total);
RunNodeTest(&Node::SimpleMap, "simple map", passed, total);
RunNodeTest(&Node::MapWithUndefinedValues, "map with undefined values",
passed, total);
RunNodeTest(&Node::MapIteratorWithUndefinedValues,
"map iterator with undefined values", passed, total);
RunNodeTest(&Node::SimpleSubkeys, "simple subkey", passed, total);
RunNodeTest(&Node::StdVector, "std::vector", passed, total);
RunNodeTest(&Node::StdList, "std::list", passed, total);
RunNodeTest(&Node::StdMap, "std::map", passed, total);
RunNodeTest(&Node::StdPair, "std::pair", passed, total);
RunNodeTest(&Node::SimpleAlias, "simple alias", passed, total);
RunNodeTest(&Node::AliasAsKey, "alias as key", passed, total);
RunNodeTest(&Node::SelfReferenceSequence, "self reference sequence", passed,
total);
RunNodeTest(&Node::ValueSelfReferenceMap, "value self reference map", passed,
total);
RunNodeTest(&Node::KeySelfReferenceMap, "key self reference map", passed,
total);
RunNodeTest(&Node::SelfReferenceMap, "self reference map", passed, total);
RunNodeTest(&Node::TempMapVariable, "temp map variable", passed, total);
RunNodeTest(&Node::TempMapVariableAlias, "temp map variable alias", passed,
total);
RunNodeTest(&Node::Bool, "bool", passed, total);
RunNodeTest(&Node::AutoBoolConversion, "auto bool conversion", passed, total);
RunNodeTest(&Node::Reassign, "reassign", passed, total);
RunNodeTest(&Node::FallbackValues, "fallback values", passed, total);
RunNodeTest(&Node::NumericConversion, "numeric conversion", passed, total);
RunNodeTest(&Node::Binary, "binary", passed, total);
RunNodeTest(&Node::IterateSequence, "iterate sequence", passed, total);
RunNodeTest(&Node::IterateMap, "iterate map", passed, total);
#ifdef BOOST_FOREACH
RunNodeTest(&Node::ForEach, "for each", passed, total);
RunNodeTest(&Node::ForEachMap, "for each map", passed, total);
#endif
RunNodeTest(&Node::CloneScalar, "clone scalar", passed, total);
RunNodeTest(&Node::CloneSeq, "clone seq", passed, total);
RunNodeTest(&Node::CloneMap, "clone map", passed, total);
RunNodeTest(&Node::CloneAlias, "clone alias", passed, total);
RunNodeTest(&Node::ForceInsertIntoMap, "force insert into map", passed,
total);
RunNodeTest(&Node::ResetNode, "reset node", passed, total);
RunNodeTest(&Node::DereferenceIteratorError, "dereference iterator error",
passed, total);
RunNodeTest(&Node::FloatingPrecision, "floating precision", passed, total);
RunNodeTest(&Node::EmitEmptyNode, "emit empty node", passed, total);
RunNodeTest(&Node::SpaceChar, "space char", passed, total);
std::cout << "Node tests: " << passed << "/" << total << " passed\n";
return passed == total;
}
}
test/node/node_test.cpp
View file @ ad0a3311
#include "gtest/gtest.h"
#include "yaml-cpp/node/node.h" #include "yaml-cpp/node/node.h"
#include "yaml-cpp/node/impl.h"
#include "yaml-cpp/node/convert.h"
#include "yaml-cpp/node/iterator.h"
#include "yaml-cpp/node/detail/impl.h"
#include "gtest/gtest.h"
namespace YAML { namespace YAML {
namespace { namespace {
TEST(NodeTest, SimpleScalar) {
YAML::Node node = YAML::Node("Hello, World!");
EXPECT_TRUE(node.IsScalar());
EXPECT_EQ("Hello, World!", node.as<std::string>());
}
TEST(NodeTest, IntScalar) {
YAML::Node node = YAML::Node(15);
EXPECT_TRUE(node.IsScalar());
EXPECT_EQ(15, node.as<int>());
}
TEST(NodeTest, SimpleAppendSequence) {
YAML::Node node;
node.push_back(10);
node.push_back("foo");
node.push_back("monkey");
EXPECT_TRUE(node.IsSequence());
EXPECT_EQ(3, node.size());
EXPECT_EQ(10, node[0].as<int>());
EXPECT_EQ("foo", node[1].as<std::string>());
EXPECT_EQ("monkey", node[2].as<std::string>());
EXPECT_TRUE(node.IsSequence());
}
TEST(NodeTest, SimpleAssignSequence) {
YAML::Node node;
node[0] = 10;
node[1] = "foo";
node[2] = "monkey";
EXPECT_TRUE(node.IsSequence());
EXPECT_EQ(3, node.size());
EXPECT_EQ(10, node[0].as<int>());
EXPECT_EQ("foo", node[1].as<std::string>());
EXPECT_EQ("monkey", node[2].as<std::string>());
EXPECT_TRUE(node.IsSequence());
}
TEST(NodeTest, SimpleMap) {
YAML::Node node;
node["key"] = "value";
EXPECT_TRUE(node.IsMap());
EXPECT_EQ("value", node["key"].as<std::string>());
EXPECT_EQ(1, node.size());
}
TEST(NodeTest, MapWithUndefinedValues) {
YAML::Node node;
node["key"] = "value";
node["undefined"];
EXPECT_TRUE(node.IsMap());
EXPECT_EQ("value", node["key"].as<std::string>());
EXPECT_EQ(1, node.size());
node["undefined"] = "monkey";
EXPECT_EQ("monkey", node["undefined"].as<std::string>());
EXPECT_EQ(2, node.size());
}
TEST(NodeTest, MapIteratorWithUndefinedValues) {
YAML::Node node;
node["key"] = "value";
node["undefined"];
std::size_t count = 0;
for (const_iterator it = node.begin(); it != node.end(); ++it)
count++;
EXPECT_EQ(1, count);
}
TEST(NodeTest, SimpleSubkeys) {
YAML::Node node;
node["device"]["udid"] = "12345";
node["device"]["name"] = "iPhone";
node["device"]["os"] = "4.0";
node["username"] = "monkey";
EXPECT_EQ("12345", node["device"]["udid"].as<std::string>());
EXPECT_EQ("iPhone", node["device"]["name"].as<std::string>());
EXPECT_EQ("4.0", node["device"]["os"].as<std::string>());
EXPECT_EQ("monkey", node["username"].as<std::string>());
}
TEST(NodeTest, StdVector) {
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);
YAML::Node node;
node["primes"] = primes;
EXPECT_EQ(primes, node["primes"].as<std::vector<int> >());
}
TEST(NodeTest, StdList) {
std::list<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);
YAML::Node node;
node["primes"] = primes;
EXPECT_EQ(primes, node["primes"].as<std::list<int> >());
}
TEST(NodeTest, StdMap) {
std::map<int, int> squares;
squares[0] = 0;
squares[1] = 1;
squares[2] = 4;
squares[3] = 9;
squares[4] = 16;
YAML::Node node;
node["squares"] = squares;
std::map<int, int> actualSquares = node["squares"].as<std::map<int, int> >();
EXPECT_EQ(squares, actualSquares);
}
TEST(NodeTest, StdPair) {
std::pair<int, std::string> p;
p.first = 5;
p.second = "five";
YAML::Node node;
node["pair"] = p;
std::pair<int, std::string> actualP =
node["pair"].as<std::pair<int, std::string> >();
EXPECT_EQ(p, actualP);
}
TEST(NodeTest, SimpleAlias) {
YAML::Node node;
node["foo"] = "value";
node["bar"] = node["foo"];
EXPECT_EQ("value", node["foo"].as<std::string>());
EXPECT_EQ("value", node["bar"].as<std::string>());
EXPECT_EQ(node["bar"], node["foo"]);
EXPECT_EQ(2, node.size());
}
TEST(NodeTest, AliasAsKey) {
YAML::Node node;
node["foo"] = "value";
YAML::Node value = node["foo"];
node[value] = "foo";
EXPECT_EQ("value", node["foo"].as<std::string>());
EXPECT_EQ("foo", node[value].as<std::string>());
EXPECT_EQ("foo", node["value"].as<std::string>());
EXPECT_EQ(2, node.size());
}
TEST(NodeTest, SelfReferenceSequence) {
YAML::Node node;
node[0] = node;
EXPECT_TRUE(node.IsSequence());
EXPECT_EQ(1, node.size());
EXPECT_EQ(node, node[0]);
EXPECT_EQ(node, node[0][0]);
EXPECT_EQ(node[0], node[0][0]);
}
TEST(NodeTest, ValueSelfReferenceMap) {
YAML::Node node;
node["key"] = node;
EXPECT_TRUE(node.IsMap());
EXPECT_EQ(1, node.size());
EXPECT_EQ(node, node["key"]);
EXPECT_EQ(node, node["key"]["key"]);
EXPECT_EQ(node["key"], node["key"]["key"]);
}
TEST(NodeTest, KeySelfReferenceMap) {
YAML::Node node;
node[node] = "value";
EXPECT_TRUE(node.IsMap());
EXPECT_EQ(1, node.size());
EXPECT_EQ("value", node[node].as<std::string>());
}
TEST(NodeTest, SelfReferenceMap) {
YAML::Node node;
node[node] = node;
EXPECT_TRUE(node.IsMap());
EXPECT_EQ(1, node.size());
EXPECT_EQ(node, node[node]);
EXPECT_EQ(node, node[node][node]);
EXPECT_EQ(node[node], node[node][node]);
}
TEST(NodeTest, TempMapVariable) {
YAML::Node node;
YAML::Node tmp = node["key"];
tmp = "value";
EXPECT_TRUE(node.IsMap());
EXPECT_EQ(1, node.size());
EXPECT_EQ("value", node["key"].as<std::string>());
}
TEST(NodeTest, TempMapVariableAlias) {
YAML::Node node;
YAML::Node tmp = node["key"];
tmp = node["other"];
node["other"] = "value";
EXPECT_TRUE(node.IsMap());
EXPECT_EQ(2, node.size());
EXPECT_EQ("value", node["key"].as<std::string>());
EXPECT_EQ("value", node["other"].as<std::string>());
EXPECT_EQ(node["key"], node["other"]);
}
TEST(NodeTest, Bool) {
YAML::Node node;
node[true] = false;
EXPECT_TRUE(node.IsMap());
EXPECT_EQ(false, node[true].as<bool>());
}
TEST(NodeTest, AutoBoolConversion) {
YAML::Node node;
node["foo"] = "bar";
EXPECT_TRUE(static_cast<bool>(node["foo"]));
EXPECT_TRUE(!node["monkey"]);
EXPECT_TRUE(!!node["foo"]);
}
TEST(NodeTest, FloatingPrecision) {
const double x = 0.123456789;
YAML::Node node = YAML::Node(x);
EXPECT_EQ(x, node.as<double>());
}
TEST(NodeTest, SpaceChar) {
YAML::Node node = YAML::Node(' ');
EXPECT_EQ(' ', node.as<char>());
}
TEST(NodeTest, CloneNull) { TEST(NodeTest, CloneNull) {
Node node; Node node;
Node clone = Clone(node); Node clone = Clone(node);
......
test/nodetests.h deleted 100644 → 0
View file @ 33424ecb
#ifndef NODETESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define NODETESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once
#endif
namespace Test {
bool RunNodeTests();
}
#endif // NODETESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A6666
test/tests.cpp deleted 100644 → 0
View file @ 33424ecb
#include <fstream>
#include <iostream>
#include <sstream>
#include <vector>
#include "nodetests.h"
#include "tests.h"
namespace Test {
void RunAll() {
bool passed = true;
if (!RunNodeTests())
passed = false;
if (passed)
std::cout << "All tests passed!\n";
}
}
test/tests.h deleted 100644 → 0
View file @ 33424ecb
#ifndef TESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define TESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once
#endif
#include <string>
namespace Test {
void RunAll();
namespace Parser {
// scalar tests
void SimpleScalar(std::string& inputScalar, std::string& desiredOutput);
void MultiLineScalar(std::string& inputScalar, std::string& desiredOutput);
void LiteralScalar(std::string& inputScalar, std::string& desiredOutput);
void FoldedScalar(std::string& inputScalar, std::string& desiredOutput);
void ChompedFoldedScalar(std::string& inputScalar, std::string& desiredOutput);
void ChompedLiteralScalar(std::string& inputScalar, std::string& desiredOutput);
void FoldedScalarWithIndent(std::string& inputScalar,
std::string& desiredOutput);
void ColonScalar(std::string& inputScalar, std::string& desiredOutput);
void QuotedScalar(std::string& inputScalar, std::string& desiredOutput);
void CommaScalar(std::string& inputScalar, std::string& desiredOutput);
void DashScalar(std::string& inputScalar, std::string& desiredOutput);
void URLScalar(std::string& inputScalar, std::string& desiredOutput);
// misc tests
bool SimpleSeq();
bool SimpleMap();
bool FlowSeq();
bool FlowMap();
bool FlowMapWithOmittedKey();
bool FlowMapWithOmittedValue();
bool FlowMapWithSoloEntry();
bool FlowMapEndingWithSoloEntry();
bool QuotedSimpleKeys();
bool CompressedMapAndSeq();
bool NullBlockSeqEntry();
bool NullBlockMapKey();
bool NullBlockMapValue();
bool SimpleAlias();
bool AliasWithNull();
bool AnchorInSimpleKey();
bool AliasAsSimpleKey();
bool ExplicitDoc();
bool MultipleDocs();
bool ExplicitEndDoc();
bool MultipleDocsWithSomeExplicitIndicators();
}
}
#endif // TESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
test/teststruct.h deleted 100644 → 0
View file @ 33424ecb
#pragma once
#include <string>
#define YAML_ASSERT(cond) \
do { \
if (!(cond)) \
return " Assert failed: " #cond; \
} while (false)
namespace Test {
struct TEST {
TEST() : ok(false) {}
TEST(bool ok_) : ok(ok_) {}
TEST(const char *error_) : ok(false), error(error_) {}
bool ok;
std::string error;
};
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment