mirror of
https://github.com/opnsense/src.git
synced 2026-03-01 04:40:53 -05:00
b0d29bc47d
Having kyua in the base system will simplify automated testing in CI and eliminates bootstrapping issues on new platforms. The build of kyua is controlled by WITH(OUT)_TESTS_SUPPORT. Reviewed by: emaste Obtained from: CheriBSD Sponsored by: DARPA Differential Revision: https://reviews.freebsd.org/D24103
695 lines
19 KiB
C++
695 lines
19 KiB
C++
// 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);
|
|
}
|