Convert node tests to gtest

test/integration/load_node_test.cpp

+#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

-#include "tests.h"
-
 #include "gtest/gtest.h"
 
 int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
-  Test::RunAll();
   return RUN_ALL_TESTS();
 }

test/node/node_test.cpp

-#include "gtest/gtest.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 {
+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) {
   Node node;
   Node clone = Clone(node);

test/nodetests.h

-#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

-#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

-#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

-#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;
-};
-}