aboutsummaryrefslogtreecommitdiffstats
path: root/utils/config/nodes_test.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'utils/config/nodes_test.cpp')
-rw-r--r--utils/config/nodes_test.cpp695
1 files changed, 695 insertions, 0 deletions
diff --git a/utils/config/nodes_test.cpp b/utils/config/nodes_test.cpp
new file mode 100644
index 000000000000..e762d3aac38c
--- /dev/null
+++ b/utils/config/nodes_test.cpp
@@ -0,0 +1,695 @@
+// Copyright 2012 The Kyua Authors.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of Google Inc. nor the names of its contributors
+// may be used to endorse or promote products derived from this software
+// without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "utils/config/nodes.ipp"
+
+#include <atf-c++.hpp>
+
+#include <lutok/state.ipp>
+
+#include "utils/config/exceptions.hpp"
+#include "utils/config/keys.hpp"
+#include "utils/defs.hpp"
+
+namespace config = utils::config;
+
+
+namespace {
+
+
+/// Typed leaf node that specializes the validate() method.
+class validation_node : public config::int_node {
+ /// Checks a given value for validity against a fake value.
+ ///
+ /// \param new_value The value to validate.
+ ///
+ /// \throw value_error If the value is not valid.
+ void
+ validate(const value_type& new_value) const
+ {
+ if (new_value == 12345)
+ throw config::value_error("Custom validate method");
+ }
+};
+
+
+/// Set node that specializes the validate() method.
+class set_validation_node : public config::strings_set_node {
+ /// Checks a given value for validity against a fake value.
+ ///
+ /// \param new_value The value to validate.
+ ///
+ /// \throw value_error If the value is not valid.
+ void
+ validate(const value_type& new_value) const
+ {
+ for (value_type::const_iterator iter = new_value.begin();
+ iter != new_value.end(); ++iter)
+ if (*iter == "throw")
+ throw config::value_error("Custom validate method");
+ }
+};
+
+
+} // anonymous namespace
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(bool_node__deep_copy);
+ATF_TEST_CASE_BODY(bool_node__deep_copy)
+{
+ config::bool_node node;
+ node.set(true);
+ config::detail::base_node* raw_copy = node.deep_copy();
+ config::bool_node* copy = static_cast< config::bool_node* >(raw_copy);
+ ATF_REQUIRE(copy->value());
+ copy->set(false);
+ ATF_REQUIRE(node.value());
+ ATF_REQUIRE(!copy->value());
+ delete copy;
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(bool_node__is_set_and_set);
+ATF_TEST_CASE_BODY(bool_node__is_set_and_set)
+{
+ config::bool_node node;
+ ATF_REQUIRE(!node.is_set());
+ node.set(false);
+ ATF_REQUIRE( node.is_set());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(bool_node__value_and_set);
+ATF_TEST_CASE_BODY(bool_node__value_and_set)
+{
+ config::bool_node node;
+ node.set(false);
+ ATF_REQUIRE(!node.value());
+ node.set(true);
+ ATF_REQUIRE( node.value());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(bool_node__push_lua);
+ATF_TEST_CASE_BODY(bool_node__push_lua)
+{
+ lutok::state state;
+
+ config::bool_node node;
+ node.set(true);
+ node.push_lua(state);
+ ATF_REQUIRE(state.is_boolean(-1));
+ ATF_REQUIRE(state.to_boolean(-1));
+ state.pop(1);
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_lua__ok);
+ATF_TEST_CASE_BODY(bool_node__set_lua__ok)
+{
+ lutok::state state;
+
+ config::bool_node node;
+ state.push_boolean(false);
+ node.set_lua(state, -1);
+ state.pop(1);
+ ATF_REQUIRE(!node.value());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_lua__invalid_value);
+ATF_TEST_CASE_BODY(bool_node__set_lua__invalid_value)
+{
+ lutok::state state;
+
+ config::bool_node node;
+ state.push_string("foo bar");
+ ATF_REQUIRE_THROW(config::value_error, node.set_lua(state, -1));
+ state.pop(1);
+ ATF_REQUIRE(!node.is_set());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_string__ok);
+ATF_TEST_CASE_BODY(bool_node__set_string__ok)
+{
+ config::bool_node node;
+ node.set_string("false");
+ ATF_REQUIRE(!node.value());
+ node.set_string("true");
+ ATF_REQUIRE( node.value());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_string__invalid_value);
+ATF_TEST_CASE_BODY(bool_node__set_string__invalid_value)
+{
+ config::bool_node node;
+ ATF_REQUIRE_THROW(config::value_error, node.set_string("12345"));
+ ATF_REQUIRE(!node.is_set());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(bool_node__to_string);
+ATF_TEST_CASE_BODY(bool_node__to_string)
+{
+ config::bool_node node;
+ node.set(false);
+ ATF_REQUIRE_EQ("false", node.to_string());
+ node.set(true);
+ ATF_REQUIRE_EQ("true", node.to_string());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(int_node__deep_copy);
+ATF_TEST_CASE_BODY(int_node__deep_copy)
+{
+ config::int_node node;
+ node.set(5);
+ config::detail::base_node* raw_copy = node.deep_copy();
+ config::int_node* copy = static_cast< config::int_node* >(raw_copy);
+ ATF_REQUIRE_EQ(5, copy->value());
+ copy->set(10);
+ ATF_REQUIRE_EQ(5, node.value());
+ ATF_REQUIRE_EQ(10, copy->value());
+ delete copy;
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(int_node__is_set_and_set);
+ATF_TEST_CASE_BODY(int_node__is_set_and_set)
+{
+ config::int_node node;
+ ATF_REQUIRE(!node.is_set());
+ node.set(20);
+ ATF_REQUIRE( node.is_set());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(int_node__value_and_set);
+ATF_TEST_CASE_BODY(int_node__value_and_set)
+{
+ config::int_node node;
+ node.set(20);
+ ATF_REQUIRE_EQ(20, node.value());
+ node.set(0);
+ ATF_REQUIRE_EQ(0, node.value());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(int_node__push_lua);
+ATF_TEST_CASE_BODY(int_node__push_lua)
+{
+ lutok::state state;
+
+ config::int_node node;
+ node.set(754);
+ node.push_lua(state);
+ ATF_REQUIRE(state.is_number(-1));
+ ATF_REQUIRE_EQ(754, state.to_integer(-1));
+ state.pop(1);
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_lua__ok);
+ATF_TEST_CASE_BODY(int_node__set_lua__ok)
+{
+ lutok::state state;
+
+ config::int_node node;
+ state.push_integer(123);
+ state.push_string("456");
+ node.set_lua(state, -2);
+ ATF_REQUIRE_EQ(123, node.value());
+ node.set_lua(state, -1);
+ ATF_REQUIRE_EQ(456, node.value());
+ state.pop(2);
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_lua__invalid_value);
+ATF_TEST_CASE_BODY(int_node__set_lua__invalid_value)
+{
+ lutok::state state;
+
+ config::int_node node;
+ state.push_boolean(true);
+ ATF_REQUIRE_THROW(config::value_error, node.set_lua(state, -1));
+ state.pop(1);
+ ATF_REQUIRE(!node.is_set());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_string__ok);
+ATF_TEST_CASE_BODY(int_node__set_string__ok)
+{
+ config::int_node node;
+ node.set_string("178");
+ ATF_REQUIRE_EQ(178, node.value());
+ node.set_string("-123");
+ ATF_REQUIRE_EQ(-123, node.value());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_string__invalid_value);
+ATF_TEST_CASE_BODY(int_node__set_string__invalid_value)
+{
+ config::int_node node;
+ ATF_REQUIRE_THROW(config::value_error, node.set_string(" 23"));
+ ATF_REQUIRE(!node.is_set());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(int_node__to_string);
+ATF_TEST_CASE_BODY(int_node__to_string)
+{
+ config::int_node node;
+ node.set(89);
+ ATF_REQUIRE_EQ("89", node.to_string());
+ node.set(-57);
+ ATF_REQUIRE_EQ("-57", node.to_string());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__deep_copy);
+ATF_TEST_CASE_BODY(positive_int_node__deep_copy)
+{
+ config::positive_int_node node;
+ node.set(5);
+ config::detail::base_node* raw_copy = node.deep_copy();
+ config::positive_int_node* copy = static_cast< config::positive_int_node* >(
+ raw_copy);
+ ATF_REQUIRE_EQ(5, copy->value());
+ copy->set(10);
+ ATF_REQUIRE_EQ(5, node.value());
+ ATF_REQUIRE_EQ(10, copy->value());
+ delete copy;
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__is_set_and_set);
+ATF_TEST_CASE_BODY(positive_int_node__is_set_and_set)
+{
+ config::positive_int_node node;
+ ATF_REQUIRE(!node.is_set());
+ node.set(20);
+ ATF_REQUIRE( node.is_set());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__value_and_set);
+ATF_TEST_CASE_BODY(positive_int_node__value_and_set)
+{
+ config::positive_int_node node;
+ node.set(20);
+ ATF_REQUIRE_EQ(20, node.value());
+ node.set(1);
+ ATF_REQUIRE_EQ(1, node.value());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__push_lua);
+ATF_TEST_CASE_BODY(positive_int_node__push_lua)
+{
+ lutok::state state;
+
+ config::positive_int_node node;
+ node.set(754);
+ node.push_lua(state);
+ ATF_REQUIRE(state.is_number(-1));
+ ATF_REQUIRE_EQ(754, state.to_integer(-1));
+ state.pop(1);
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_lua__ok);
+ATF_TEST_CASE_BODY(positive_int_node__set_lua__ok)
+{
+ lutok::state state;
+
+ config::positive_int_node node;
+ state.push_integer(123);
+ state.push_string("456");
+ node.set_lua(state, -2);
+ ATF_REQUIRE_EQ(123, node.value());
+ node.set_lua(state, -1);
+ ATF_REQUIRE_EQ(456, node.value());
+ state.pop(2);
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_lua__invalid_value);
+ATF_TEST_CASE_BODY(positive_int_node__set_lua__invalid_value)
+{
+ lutok::state state;
+
+ config::positive_int_node node;
+ state.push_boolean(true);
+ ATF_REQUIRE_THROW(config::value_error, node.set_lua(state, -1));
+ state.pop(1);
+ ATF_REQUIRE(!node.is_set());
+ state.push_integer(0);
+ ATF_REQUIRE_THROW(config::value_error, node.set_lua(state, -1));
+ state.pop(1);
+ ATF_REQUIRE(!node.is_set());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_string__ok);
+ATF_TEST_CASE_BODY(positive_int_node__set_string__ok)
+{
+ config::positive_int_node node;
+ node.set_string("1");
+ ATF_REQUIRE_EQ(1, node.value());
+ node.set_string("178");
+ ATF_REQUIRE_EQ(178, node.value());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_string__invalid_value);
+ATF_TEST_CASE_BODY(positive_int_node__set_string__invalid_value)
+{
+ config::positive_int_node node;
+ ATF_REQUIRE_THROW(config::value_error, node.set_string(" 23"));
+ ATF_REQUIRE(!node.is_set());
+ ATF_REQUIRE_THROW(config::value_error, node.set_string("0"));
+ ATF_REQUIRE(!node.is_set());
+ ATF_REQUIRE_THROW(config::value_error, node.set_string("-5"));
+ ATF_REQUIRE(!node.is_set());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__to_string);
+ATF_TEST_CASE_BODY(positive_int_node__to_string)
+{
+ config::positive_int_node node;
+ node.set(89);
+ ATF_REQUIRE_EQ("89", node.to_string());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(string_node__deep_copy);
+ATF_TEST_CASE_BODY(string_node__deep_copy)
+{
+ config::string_node node;
+ node.set("first");
+ config::detail::base_node* raw_copy = node.deep_copy();
+ config::string_node* copy = static_cast< config::string_node* >(raw_copy);
+ ATF_REQUIRE_EQ("first", copy->value());
+ copy->set("second");
+ ATF_REQUIRE_EQ("first", node.value());
+ ATF_REQUIRE_EQ("second", copy->value());
+ delete copy;
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(string_node__is_set_and_set);
+ATF_TEST_CASE_BODY(string_node__is_set_and_set)
+{
+ config::string_node node;
+ ATF_REQUIRE(!node.is_set());
+ node.set("foo");
+ ATF_REQUIRE( node.is_set());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(string_node__value_and_set);
+ATF_TEST_CASE_BODY(string_node__value_and_set)
+{
+ config::string_node node;
+ node.set("foo");
+ ATF_REQUIRE_EQ("foo", node.value());
+ node.set("");
+ ATF_REQUIRE_EQ("", node.value());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(string_node__push_lua);
+ATF_TEST_CASE_BODY(string_node__push_lua)
+{
+ lutok::state state;
+
+ config::string_node node;
+ node.set("some message");
+ node.push_lua(state);
+ ATF_REQUIRE(state.is_string(-1));
+ ATF_REQUIRE_EQ("some message", state.to_string(-1));
+ state.pop(1);
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(string_node__set_lua__ok);
+ATF_TEST_CASE_BODY(string_node__set_lua__ok)
+{
+ lutok::state state;
+
+ config::string_node node;
+ state.push_string("text 1");
+ state.push_integer(231);
+ node.set_lua(state, -2);
+ ATF_REQUIRE_EQ("text 1", node.value());
+ node.set_lua(state, -1);
+ ATF_REQUIRE_EQ("231", node.value());
+ state.pop(2);
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(string_node__set_lua__invalid_value);
+ATF_TEST_CASE_BODY(string_node__set_lua__invalid_value)
+{
+ lutok::state state;
+
+ config::bool_node node;
+ state.new_table();
+ ATF_REQUIRE_THROW(config::value_error, node.set_lua(state, -1));
+ state.pop(1);
+ ATF_REQUIRE(!node.is_set());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(string_node__set_string);
+ATF_TEST_CASE_BODY(string_node__set_string)
+{
+ config::string_node node;
+ node.set_string("abcd efgh");
+ ATF_REQUIRE_EQ("abcd efgh", node.value());
+ node.set_string(" 1234 ");
+ ATF_REQUIRE_EQ(" 1234 ", node.value());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(string_node__to_string);
+ATF_TEST_CASE_BODY(string_node__to_string)
+{
+ config::string_node node;
+ node.set("");
+ ATF_REQUIRE_EQ("", node.to_string());
+ node.set("aaa");
+ ATF_REQUIRE_EQ("aaa", node.to_string());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__deep_copy);
+ATF_TEST_CASE_BODY(strings_set_node__deep_copy)
+{
+ std::set< std::string > value;
+ config::strings_set_node node;
+ value.insert("foo");
+ node.set(value);
+ config::detail::base_node* raw_copy = node.deep_copy();
+ config::strings_set_node* copy =
+ static_cast< config::strings_set_node* >(raw_copy);
+ value.insert("bar");
+ ATF_REQUIRE_EQ(1, copy->value().size());
+ copy->set(value);
+ ATF_REQUIRE_EQ(1, node.value().size());
+ ATF_REQUIRE_EQ(2, copy->value().size());
+ delete copy;
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__is_set_and_set);
+ATF_TEST_CASE_BODY(strings_set_node__is_set_and_set)
+{
+ std::set< std::string > value;
+ value.insert("foo");
+
+ config::strings_set_node node;
+ ATF_REQUIRE(!node.is_set());
+ node.set(value);
+ ATF_REQUIRE( node.is_set());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__value_and_set);
+ATF_TEST_CASE_BODY(strings_set_node__value_and_set)
+{
+ std::set< std::string > value;
+ value.insert("first");
+
+ config::strings_set_node node;
+ node.set(value);
+ ATF_REQUIRE(value == node.value());
+ value.clear();
+ node.set(value);
+ value.insert("second");
+ ATF_REQUIRE(node.value().empty());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__set_string);
+ATF_TEST_CASE_BODY(strings_set_node__set_string)
+{
+ config::strings_set_node node;
+ {
+ std::set< std::string > expected;
+ expected.insert("abcd");
+ expected.insert("efgh");
+
+ node.set_string("abcd efgh");
+ ATF_REQUIRE(expected == node.value());
+ }
+ {
+ std::set< std::string > expected;
+ expected.insert("1234");
+
+ node.set_string(" 1234 ");
+ ATF_REQUIRE(expected == node.value());
+ }
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__to_string);
+ATF_TEST_CASE_BODY(strings_set_node__to_string)
+{
+ std::set< std::string > value;
+ config::strings_set_node node;
+ value.insert("second");
+ value.insert("first");
+ node.set(value);
+ ATF_REQUIRE_EQ("first second", node.to_string());
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(typed_leaf_node__validate_set);
+ATF_TEST_CASE_BODY(typed_leaf_node__validate_set)
+{
+ validation_node node;
+ node.set(1234);
+ ATF_REQUIRE_THROW_RE(config::value_error, "Custom validate method",
+ node.set(12345));
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(typed_leaf_node__validate_set_string);
+ATF_TEST_CASE_BODY(typed_leaf_node__validate_set_string)
+{
+ validation_node node;
+ node.set_string("1234");
+ ATF_REQUIRE_THROW_RE(config::value_error, "Custom validate method",
+ node.set_string("12345"));
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(base_set_node__validate_set);
+ATF_TEST_CASE_BODY(base_set_node__validate_set)
+{
+ set_validation_node node;
+ set_validation_node::value_type values;
+ values.insert("foo");
+ values.insert("bar");
+ node.set(values);
+ values.insert("throw");
+ values.insert("baz");
+ ATF_REQUIRE_THROW_RE(config::value_error, "Custom validate method",
+ node.set(values));
+}
+
+
+ATF_TEST_CASE_WITHOUT_HEAD(base_set_node__validate_set_string);
+ATF_TEST_CASE_BODY(base_set_node__validate_set_string)
+{
+ set_validation_node node;
+ node.set_string("foo bar");
+ ATF_REQUIRE_THROW_RE(config::value_error, "Custom validate method",
+ node.set_string("foo bar throw baz"));
+}
+
+
+ATF_INIT_TEST_CASES(tcs)
+{
+ ATF_ADD_TEST_CASE(tcs, bool_node__deep_copy);
+ ATF_ADD_TEST_CASE(tcs, bool_node__is_set_and_set);
+ ATF_ADD_TEST_CASE(tcs, bool_node__value_and_set);
+ ATF_ADD_TEST_CASE(tcs, bool_node__push_lua);
+ ATF_ADD_TEST_CASE(tcs, bool_node__set_lua__ok);
+ ATF_ADD_TEST_CASE(tcs, bool_node__set_lua__invalid_value);
+ ATF_ADD_TEST_CASE(tcs, bool_node__set_string__ok);
+ ATF_ADD_TEST_CASE(tcs, bool_node__set_string__invalid_value);
+ ATF_ADD_TEST_CASE(tcs, bool_node__to_string);
+
+ ATF_ADD_TEST_CASE(tcs, int_node__deep_copy);
+ ATF_ADD_TEST_CASE(tcs, int_node__is_set_and_set);
+ ATF_ADD_TEST_CASE(tcs, int_node__value_and_set);
+ ATF_ADD_TEST_CASE(tcs, int_node__push_lua);
+ ATF_ADD_TEST_CASE(tcs, int_node__set_lua__ok);
+ ATF_ADD_TEST_CASE(tcs, int_node__set_lua__invalid_value);
+ ATF_ADD_TEST_CASE(tcs, int_node__set_string__ok);
+ ATF_ADD_TEST_CASE(tcs, int_node__set_string__invalid_value);
+ ATF_ADD_TEST_CASE(tcs, int_node__to_string);
+
+ ATF_ADD_TEST_CASE(tcs, positive_int_node__deep_copy);
+ ATF_ADD_TEST_CASE(tcs, positive_int_node__is_set_and_set);
+ ATF_ADD_TEST_CASE(tcs, positive_int_node__value_and_set);
+ ATF_ADD_TEST_CASE(tcs, positive_int_node__push_lua);
+ ATF_ADD_TEST_CASE(tcs, positive_int_node__set_lua__ok);
+ ATF_ADD_TEST_CASE(tcs, positive_int_node__set_lua__invalid_value);
+ ATF_ADD_TEST_CASE(tcs, positive_int_node__set_string__ok);
+ ATF_ADD_TEST_CASE(tcs, positive_int_node__set_string__invalid_value);
+ ATF_ADD_TEST_CASE(tcs, positive_int_node__to_string);
+
+ ATF_ADD_TEST_CASE(tcs, string_node__deep_copy);
+ ATF_ADD_TEST_CASE(tcs, string_node__is_set_and_set);
+ ATF_ADD_TEST_CASE(tcs, string_node__value_and_set);
+ ATF_ADD_TEST_CASE(tcs, string_node__push_lua);
+ ATF_ADD_TEST_CASE(tcs, string_node__set_lua__ok);
+ ATF_ADD_TEST_CASE(tcs, string_node__set_lua__invalid_value);
+ ATF_ADD_TEST_CASE(tcs, string_node__set_string);
+ ATF_ADD_TEST_CASE(tcs, string_node__to_string);
+
+ ATF_ADD_TEST_CASE(tcs, strings_set_node__deep_copy);
+ ATF_ADD_TEST_CASE(tcs, strings_set_node__is_set_and_set);
+ ATF_ADD_TEST_CASE(tcs, strings_set_node__value_and_set);
+ ATF_ADD_TEST_CASE(tcs, strings_set_node__set_string);
+ ATF_ADD_TEST_CASE(tcs, strings_set_node__to_string);
+
+ ATF_ADD_TEST_CASE(tcs, typed_leaf_node__validate_set);
+ ATF_ADD_TEST_CASE(tcs, typed_leaf_node__validate_set_string);
+ ATF_ADD_TEST_CASE(tcs, base_set_node__validate_set);
+ ATF_ADD_TEST_CASE(tcs, base_set_node__validate_set_string);
+}