zhangyiss/toml11
1
0
Fork 0
mirror of https://github.com/ToruNiina/toml11.git synced 2025-09-18 19:10:11 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix: fix test case name

Browse Source
This commit is contained in:
ToruNiina
2019-06-21 15:00:41 +09:00
parent 4032b438c0
commit dd9b04ae3b
4 changed files with 212 additions and 250 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tests/test_format_error.cpp
View File

@@ -1,4 +1,4 @@
#define BOOST_TEST_MODULE "test_value" #define BOOST_TEST_MODULE "test_format_error"
#ifdef UNITTEST_FRAMEWORK_LIBRARY_EXIST #ifdef UNITTEST_FRAMEWORK_LIBRARY_EXIST
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
#else #else

338
tests/test_get.cpp
View File

@@ -5,294 +5,284 @@
#define BOOST_TEST_NO_LIB #define BOOST_TEST_NO_LIB
#include <boost/test/included/unit_test.hpp> #include <boost/test/included/unit_test.hpp>
#endif #endif
#include <toml/value.hpp> #include <toml.hpp>
#include <toml/get.hpp>
#include <map> #include <map>
#include <unordered_map> #include <unordered_map>
#include <list> #include <list>
#include <deque> #include <deque>
#include <array> #include <array>
#include <tuple>
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
#include <string_view> #include <string_view>
#endif #endif
using test_value_types = std::tuple<
toml::value,
toml::basic_value<toml::preserve_comments>,
toml::basic_value<toml::discard_comments, std::map, std::deque>,
toml::basic_value<toml::preserve_comments, std::map, std::deque>
>;
BOOST_AUTO_TEST_CASE(test_get_exact) BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
{ {
{ {
toml::value v(true); value_type v(true);
BOOST_CHECK_EQUAL(true, toml::get<toml::boolean>(v)); BOOST_TEST(true == toml::get<toml::boolean>(v));
toml::get<toml::boolean>(v) = false; toml::get<toml::boolean>(v) = false;
BOOST_CHECK_EQUAL(false, toml::get<toml::boolean>(v)); BOOST_TEST(false == toml::get<toml::boolean>(v));
} }
{ {
toml::value v(42); value_type v(42);
BOOST_CHECK_EQUAL(toml::integer(42), toml::get<toml::integer>(v)); BOOST_TEST(toml::integer(42) == toml::get<toml::integer>(v));
toml::get<toml::integer>(v) = 54; toml::get<toml::integer>(v) = 54;
BOOST_CHECK_EQUAL(toml::integer(54), toml::get<toml::integer>(v)); BOOST_TEST(toml::integer(54) == toml::get<toml::integer>(v));
} }
{ {
toml::value v(3.14); value_type v(3.14);
BOOST_CHECK_EQUAL(toml::floating(3.14), toml::get<toml::floating>(v)); BOOST_TEST(toml::floating(3.14) == toml::get<toml::floating>(v));
toml::get<toml::floating>(v) = 2.71; toml::get<toml::floating>(v) = 2.71;
BOOST_CHECK_EQUAL(toml::floating(2.71), toml::get<toml::floating>(v)); BOOST_TEST(toml::floating(2.71) == toml::get<toml::floating>(v));
} }
{ {
toml::value v("foo"); value_type v("foo");
BOOST_CHECK_EQUAL(toml::string("foo", toml::string_t::basic), BOOST_TEST(toml::string("foo", toml::string_t::basic) ==
toml::get<toml::string>(v)); toml::get<toml::string>(v));
toml::get<toml::string>(v).str += "bar"; toml::get<toml::string>(v).str += "bar";
BOOST_CHECK_EQUAL(toml::string("foobar", toml::string_t::basic), BOOST_TEST(toml::string("foobar", toml::string_t::basic) ==
toml::get<toml::string>(v)); toml::get<toml::string>(v));
} }
{ {
toml::value v("foo", toml::string_t::literal); value_type v("foo", toml::string_t::literal);
BOOST_CHECK_EQUAL(toml::string("foo", toml::string_t::literal), BOOST_TEST(toml::string("foo", toml::string_t::literal) ==
toml::get<toml::string>(v)); toml::get<toml::string>(v));
toml::get<toml::string>(v).str += "bar"; toml::get<toml::string>(v).str += "bar";
BOOST_CHECK_EQUAL(toml::string("foobar", toml::string_t::literal), BOOST_TEST(toml::string("foobar", toml::string_t::literal) ==
toml::get<toml::string>(v)); toml::get<toml::string>(v));
} }
{ {
toml::local_date d(2018, toml::month_t::Apr, 22); toml::local_date d(2018, toml::month_t::Apr, 22);
toml::value v(d); value_type v(d);
BOOST_CHECK(d == toml::get<toml::local_date>(v)); BOOST_TEST(d == toml::get<toml::local_date>(v));
toml::get<toml::local_date>(v).year = 2017; toml::get<toml::local_date>(v).year = 2017;
d.year = 2017; d.year = 2017;
BOOST_CHECK(d == toml::get<toml::local_date>(v)); BOOST_TEST(d == toml::get<toml::local_date>(v));
} }
{ {
toml::local_time t(12, 30, 45); toml::local_time t(12, 30, 45);
toml::value v(t); value_type v(t);
BOOST_CHECK(t == toml::get<toml::local_time>(v)); BOOST_TEST(t == toml::get<toml::local_time>(v));
toml::get<toml::local_time>(v).hour = 9; toml::get<toml::local_time>(v).hour = 9;
t.hour = 9; t.hour = 9;
BOOST_CHECK(t == toml::get<toml::local_time>(v)); BOOST_TEST(t == toml::get<toml::local_time>(v));
} }
{ {
toml::local_datetime dt(toml::local_date(2018, toml::month_t::Apr, 22), toml::local_datetime dt(toml::local_date(2018, toml::month_t::Apr, 22),
toml::local_time(12, 30, 45)); toml::local_time(12, 30, 45));
toml::value v(dt); value_type v(dt);
BOOST_CHECK(dt == toml::get<toml::local_datetime>(v)); BOOST_TEST(dt == toml::get<toml::local_datetime>(v));
toml::get<toml::local_datetime>(v).date.year = 2017; toml::get<toml::local_datetime>(v).date.year = 2017;
dt.date.year = 2017; dt.date.year = 2017;
BOOST_CHECK(dt == toml::get<toml::local_datetime>(v)); BOOST_TEST(dt == toml::get<toml::local_datetime>(v));
} }
{ {
toml::offset_datetime dt(toml::local_datetime( toml::offset_datetime dt(toml::local_datetime(
toml::local_date(2018, toml::month_t::Apr, 22), toml::local_date(2018, toml::month_t::Apr, 22),
toml::local_time(12, 30, 45)), toml::time_offset(9, 0)); toml::local_time(12, 30, 45)), toml::time_offset(9, 0));
toml::value v(dt); value_type v(dt);
BOOST_CHECK(dt == toml::get<toml::offset_datetime>(v)); BOOST_TEST(dt == toml::get<toml::offset_datetime>(v));
toml::get<toml::offset_datetime>(v).date.year = 2017; toml::get<toml::offset_datetime>(v).date.year = 2017;
dt.date.year = 2017; dt.date.year = 2017;
BOOST_CHECK(dt == toml::get<toml::offset_datetime>(v)); BOOST_TEST(dt == toml::get<toml::offset_datetime>(v));
} }
{ {
toml::array vec; using array_type = typename value_type::array_type;
vec.push_back(toml::value(42)); array_type vec;
vec.push_back(toml::value(54)); vec.push_back(value_type(42));
toml::value v(vec); vec.push_back(value_type(54));
BOOST_CHECK(vec == toml::get<toml::array>(v)); value_type v(vec);
BOOST_TEST(vec == toml::get<array_type>(v));
toml::get<toml::array>(v).push_back(toml::value(123)); toml::get<array_type>(v).push_back(value_type(123));
vec.push_back(toml::value(123)); vec.push_back(value_type(123));
BOOST_CHECK(vec == toml::get<toml::array>(v)); BOOST_TEST(vec == toml::get<array_type>(v));
} }
{ {
toml::table tab; using table_type = typename value_type::table_type;
tab["key1"] = toml::value(42); table_type tab;
tab["key2"] = toml::value(3.14); tab["key1"] = value_type(42);
toml::value v(tab); tab["key2"] = value_type(3.14);
BOOST_CHECK(tab == toml::get<toml::table>(v)); value_type v(tab);
BOOST_TEST(tab == toml::get<table_type>(v));
toml::get<toml::table>(v)["key3"] = toml::value(123); toml::get<table_type>(v)["key3"] = value_type(123);
tab["key3"] = toml::value(123); tab["key3"] = value_type(123);
BOOST_CHECK(tab == toml::get<toml::table>(v)); BOOST_TEST(tab == toml::get<table_type>(v));
} }
{ {
toml::value v1(42); value_type v1(42);
BOOST_CHECK(v1 == toml::get<toml::value>(v1)); BOOST_TEST(v1 == toml::get<value_type>(v1));
toml::value v2(54); value_type v2(54);
toml::get<toml::value>(v1) = v2; toml::get<value_type>(v1) = v2;
BOOST_CHECK(v2 == toml::get<toml::value>(v1)); BOOST_TEST(v2 == toml::get<value_type>(v1));
} }
} }
BOOST_AUTO_TEST_CASE(test_get_integer_type) BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_integer_type, value_type, test_value_types)
{ {
{ {
toml::value v(42); value_type v(42);
BOOST_CHECK_EQUAL(int(42), toml::get<int >(v)); BOOST_TEST(int(42) == toml::get<int >(v));
BOOST_CHECK_EQUAL(short(42), toml::get<short >(v)); BOOST_TEST(short(42) == toml::get<short >(v));
BOOST_CHECK_EQUAL(char(42), toml::get<char >(v)); BOOST_TEST(char(42) == toml::get<char >(v));
BOOST_CHECK_EQUAL(unsigned(42), toml::get<unsigned >(v)); BOOST_TEST(unsigned(42) == toml::get<unsigned >(v));
BOOST_CHECK_EQUAL(long(42), toml::get<long >(v)); BOOST_TEST(long(42) == toml::get<long >(v));
BOOST_CHECK_EQUAL(std::int64_t(42), toml::get<std::int64_t >(v)); BOOST_TEST(std::int64_t(42) == toml::get<std::int64_t >(v));
BOOST_CHECK_EQUAL(std::uint64_t(42), toml::get<std::uint64_t>(v)); BOOST_TEST(std::uint64_t(42) == toml::get<std::uint64_t>(v));
BOOST_CHECK_EQUAL(std::int16_t(42), toml::get<std::int16_t >(v)); BOOST_TEST(std::int16_t(42) == toml::get<std::int16_t >(v));
BOOST_CHECK_EQUAL(std::uint16_t(42), toml::get<std::uint16_t>(v)); BOOST_TEST(std::uint16_t(42) == toml::get<std::uint16_t>(v));
} }
} }
BOOST_AUTO_TEST_CASE(test_get_floating_type) BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_floating_type, value_type, test_value_types)
{ {
{ {
toml::value v(3.14); value_type v(3.14);
BOOST_CHECK_EQUAL(static_cast<float >(3.14), toml::get<float >(v)); BOOST_TEST(static_cast<float >(3.14) == toml::get<float >(v));
BOOST_CHECK_EQUAL(static_cast<double >(3.14), toml::get<double >(v)); BOOST_TEST(static_cast<double >(3.14) == toml::get<double >(v));
BOOST_CHECK_EQUAL(static_cast<long double>(3.14), toml::get<long double>(v)); BOOST_TEST(static_cast<long double>(3.14) == toml::get<long double>(v));
} }
} }
BOOST_AUTO_TEST_CASE(test_get_string_type) BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_string_type, value_type, test_value_types)
{ {
{ {
toml::value v("foo", toml::string_t::basic); value_type v("foo", toml::string_t::basic);
BOOST_CHECK_EQUAL("foo", toml::get<std::string>(v)); BOOST_TEST("foo" == toml::get<std::string>(v));
toml::get<std::string>(v) += "bar"; toml::get<std::string>(v) += "bar";
BOOST_CHECK_EQUAL("foobar", toml::get<std::string>(v)); BOOST_TEST("foobar" == toml::get<std::string>(v));
} }
{ {
toml::value v("foo", toml::string_t::literal); value_type v("foo", toml::string_t::literal);
BOOST_CHECK_EQUAL("foo", toml::get<std::string>(v)); BOOST_TEST("foo" == toml::get<std::string>(v));
toml::get<std::string>(v) += "bar"; toml::get<std::string>(v) += "bar";
BOOST_CHECK_EQUAL("foobar", toml::get<std::string>(v)); BOOST_TEST("foobar" == toml::get<std::string>(v));
} }
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
{ {
toml::value v("foo", toml::string_t::basic); value_type v("foo", toml::string_t::basic);
BOOST_CHECK_EQUAL("foo", toml::get<std::string_view>(v)); BOOST_TEST("foo" == toml::get<std::string_view>(v));
} }
{ {
toml::value v("foo", toml::string_t::literal); value_type v("foo", toml::string_t::literal);
BOOST_CHECK_EQUAL("foo", toml::get<std::string_view>(v)); BOOST_TEST("foo" == toml::get<std::string_view>(v));
} }
#endif #endif
} }
BOOST_AUTO_TEST_CASE(test_get_toml_array) BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_array, value_type, test_value_types)
{ {
toml::value v(toml::array(0)); const value_type v{42, 54, 69, 72};
toml::get<toml::array>(v).push_back(toml::value(42));
toml::get<toml::array>(v).push_back(toml::value(54));
toml::get<toml::array>(v).push_back(toml::value(69));
toml::get<toml::array>(v).push_back(toml::value(72));
const std::vector<int> vec = toml::get<std::vector<int>>(v); const std::vector<int> vec = toml::get<std::vector<int>>(v);
const std::list<short> lst = toml::get<std::list<short>>(v); const std::list<short> lst = toml::get<std::list<short>>(v);
const std::deque<std::int64_t> deq = toml::get<std::deque<std::int64_t>>(v); const std::deque<std::int64_t> deq = toml::get<std::deque<std::int64_t>>(v);
BOOST_CHECK_EQUAL(42, vec.at(0)); BOOST_TEST(42 == vec.at(0));
BOOST_CHECK_EQUAL(54, vec.at(1)); BOOST_TEST(54 == vec.at(1));
BOOST_CHECK_EQUAL(69, vec.at(2)); BOOST_TEST(69 == vec.at(2));
BOOST_CHECK_EQUAL(72, vec.at(3)); BOOST_TEST(72 == vec.at(3));
std::list<short>::const_iterator iter = lst.begin(); std::list<short>::const_iterator iter = lst.begin();
BOOST_CHECK_EQUAL(static_cast<short>(42), *(iter++)); BOOST_TEST(static_cast<short>(42) == *(iter++));
BOOST_CHECK_EQUAL(static_cast<short>(54), *(iter++)); BOOST_TEST(static_cast<short>(54) == *(iter++));
BOOST_CHECK_EQUAL(static_cast<short>(69), *(iter++)); BOOST_TEST(static_cast<short>(69) == *(iter++));
BOOST_CHECK_EQUAL(static_cast<short>(72), *(iter++)); BOOST_TEST(static_cast<short>(72) == *(iter++));
BOOST_CHECK_EQUAL(static_cast<std::int64_t>(42), deq.at(0)); BOOST_TEST(static_cast<std::int64_t>(42) == deq.at(0));
BOOST_CHECK_EQUAL(static_cast<std::int64_t>(54), deq.at(1)); BOOST_TEST(static_cast<std::int64_t>(54) == deq.at(1));
BOOST_CHECK_EQUAL(static_cast<std::int64_t>(69), deq.at(2)); BOOST_TEST(static_cast<std::int64_t>(69) == deq.at(2));
BOOST_CHECK_EQUAL(static_cast<std::int64_t>(72), deq.at(3)); BOOST_TEST(static_cast<std::int64_t>(72) == deq.at(3));
std::array<int, 4> ary = toml::get<std::array<int, 4>>(v); std::array<int, 4> ary = toml::get<std::array<int, 4>>(v);
BOOST_CHECK_EQUAL(static_cast<int>(42), ary.at(0)); BOOST_TEST(static_cast<int>(42) == ary.at(0));
BOOST_CHECK_EQUAL(static_cast<int>(54), ary.at(1)); BOOST_TEST(static_cast<int>(54) == ary.at(1));
BOOST_CHECK_EQUAL(static_cast<int>(69), ary.at(2)); BOOST_TEST(static_cast<int>(69) == ary.at(2));
BOOST_CHECK_EQUAL(static_cast<int>(72), ary.at(3)); BOOST_TEST(static_cast<int>(72) == ary.at(3));
std::tuple<int, short, unsigned, long> tpl = std::tuple<int, short, unsigned, long> tpl =
toml::get<std::tuple<int, short, unsigned, long>>(v); toml::get<std::tuple<int, short, unsigned, long>>(v);
BOOST_CHECK_EQUAL(static_cast<int >(42), std::get<0>(tpl)); BOOST_TEST(static_cast<int >(42) == std::get<0>(tpl));
BOOST_CHECK_EQUAL(static_cast<short >(54), std::get<1>(tpl)); BOOST_TEST(static_cast<short >(54) == std::get<1>(tpl));
BOOST_CHECK_EQUAL(static_cast<unsigned>(69), std::get<2>(tpl)); BOOST_TEST(static_cast<unsigned>(69) == std::get<2>(tpl));
BOOST_CHECK_EQUAL(static_cast<long >(72), std::get<3>(tpl)); BOOST_TEST(static_cast<long >(72) == std::get<3>(tpl));
toml::value p(toml::array{}); const value_type p{3.14, 2.71};
toml::get<toml::array>(p).push_back(toml::value(3.14));
toml::get<toml::array>(p).push_back(toml::value(2.71));
std::pair<double, double> pr = toml::get<std::pair<double, double> >(p); std::pair<double, double> pr = toml::get<std::pair<double, double> >(p);
BOOST_CHECK_EQUAL(3.14, pr.first); BOOST_TEST(3.14 == pr.first);
BOOST_CHECK_EQUAL(2.71, pr.second); BOOST_TEST(2.71 == pr.second);
} }
BOOST_AUTO_TEST_CASE(test_get_toml_array_of_array) BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_array_of_array, value_type, test_value_types)
{ {
toml::value v1(toml::array{}); const value_type v1{42, 54, 69, 72};
toml::get<toml::array>(v1).push_back(toml::value(42)); const value_type v2{"foo", "bar", "baz"};
toml::get<toml::array>(v1).push_back(toml::value(54)); const value_type v{v1, v2};
toml::get<toml::array>(v1).push_back(toml::value(69));
toml::get<toml::array>(v1).push_back(toml::value(72));
toml::value v2(toml::array{});
toml::get<toml::array>(v2).push_back(toml::value("foo"));
toml::get<toml::array>(v2).push_back(toml::value("bar"));
toml::get<toml::array>(v2).push_back(toml::value("baz"));
toml::value v(toml::array(2));
toml::get<toml::array>(v).at(0) = v1;
toml::get<toml::array>(v).at(1) = v2;
std::pair<std::vector<int>, std::vector<std::string>> p = std::pair<std::vector<int>, std::vector<std::string>> p =
toml::get<std::pair<std::vector<int>, std::vector<std::string>>>(v); toml::get<std::pair<std::vector<int>, std::vector<std::string>>>(v);
BOOST_CHECK_EQUAL(p.first.at(0), 42); BOOST_TEST(p.first.at(0) == 42);
BOOST_CHECK_EQUAL(p.first.at(1), 54); BOOST_TEST(p.first.at(1) == 54);
BOOST_CHECK_EQUAL(p.first.at(2), 69); BOOST_TEST(p.first.at(2) == 69);
BOOST_CHECK_EQUAL(p.first.at(3), 72); BOOST_TEST(p.first.at(3) == 72);
BOOST_CHECK_EQUAL(p.second.at(0), "foo"); BOOST_TEST(p.second.at(0) == "foo");
BOOST_CHECK_EQUAL(p.second.at(1), "bar"); BOOST_TEST(p.second.at(1) == "bar");
BOOST_CHECK_EQUAL(p.second.at(2), "baz"); BOOST_TEST(p.second.at(2) == "baz");
std::tuple<std::vector<int>, std::vector<std::string>> t = std::tuple<std::vector<int>, std::vector<std::string>> t =
toml::get<std::tuple<std::vector<int>, std::vector<std::string>>>(v); toml::get<std::tuple<std::vector<int>, std::vector<std::string>>>(v);
BOOST_CHECK_EQUAL(std::get<0>(t).at(0), 42); BOOST_TEST(std::get<0>(t).at(0) == 42);
BOOST_CHECK_EQUAL(std::get<0>(t).at(1), 54); BOOST_TEST(std::get<0>(t).at(1) == 54);
BOOST_CHECK_EQUAL(std::get<0>(t).at(2), 69); BOOST_TEST(std::get<0>(t).at(2) == 69);
BOOST_CHECK_EQUAL(std::get<0>(t).at(3), 72); BOOST_TEST(std::get<0>(t).at(3) == 72);
BOOST_CHECK_EQUAL(std::get<1>(t).at(0), "foo"); BOOST_TEST(std::get<1>(t).at(0) == "foo");
BOOST_CHECK_EQUAL(std::get<1>(t).at(1), "bar"); BOOST_TEST(std::get<1>(t).at(1) == "bar");
BOOST_CHECK_EQUAL(std::get<1>(t).at(2), "baz"); BOOST_TEST(std::get<1>(t).at(2) == "baz");
} }
BOOST_AUTO_TEST_CASE(test_get_toml_table) BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_table, value_type, test_value_types)
{ {
toml::value v1(toml::table{ const value_type v1{
{"key1", 1}, {"key1", 1},
{"key2", 2}, {"key2", 2},
{"key3", 3}, {"key3", 3},
{"key4", 4} {"key4", 4}
}); };
const auto v = toml::get<std::map<std::string, int>>(v1); const auto v = toml::get<std::map<std::string, int>>(v1);
BOOST_CHECK_EQUAL(v.at("key1"), 1); BOOST_TEST(v.at("key1") == 1);
BOOST_CHECK_EQUAL(v.at("key2"), 2); BOOST_TEST(v.at("key2") == 2);
BOOST_CHECK_EQUAL(v.at("key3"), 3); BOOST_TEST(v.at("key3") == 3);
BOOST_CHECK_EQUAL(v.at("key4"), 4); BOOST_TEST(v.at("key4") == 4);
} }
BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_local_date, value_type, test_value_types)
BOOST_AUTO_TEST_CASE(test_get_toml_local_date)
{ {
toml::value v1(toml::local_date{2018, toml::month_t::Apr, 1}); value_type v1(toml::local_date{2018, toml::month_t::Apr, 1});
const auto date = std::chrono::system_clock::to_time_t( const auto date = std::chrono::system_clock::to_time_t(
toml::get<std::chrono::system_clock::time_point>(v1)); toml::get<std::chrono::system_clock::time_point>(v1));
@@ -305,20 +295,22 @@ BOOST_AUTO_TEST_CASE(test_get_toml_local_date)
t.tm_sec = 0; t.tm_sec = 0;
t.tm_isdst = -1; t.tm_isdst = -1;
const auto c = std::mktime(&t); const auto c = std::mktime(&t);
BOOST_CHECK_EQUAL(c, date); BOOST_TEST(c == date);
} }
BOOST_AUTO_TEST_CASE(test_get_toml_local_time) BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_local_time, value_type, test_value_types)
{ {
toml::value v1(toml::local_time{12, 30, 45}); value_type v1(toml::local_time{12, 30, 45});
const auto time = toml::get<std::chrono::seconds>(v1); const auto time = toml::get<std::chrono::seconds>(v1);
BOOST_CHECK(time == std::chrono::hours(12) + const bool result = time == std::chrono::hours(12) +
std::chrono::minutes(30) + std::chrono::seconds(45)); std::chrono::minutes(30) +
std::chrono::seconds(45);
BOOST_TEST(result);
} }
BOOST_AUTO_TEST_CASE(test_get_toml_local_datetime) BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_local_datetime, value_type, test_value_types)
{ {
toml::value v1(toml::local_datetime( value_type v1(toml::local_datetime(
toml::local_date{2018, toml::month_t::Apr, 1}, toml::local_date{2018, toml::month_t::Apr, 1},
toml::local_time{12, 30, 45})); toml::local_time{12, 30, 45}));
@@ -333,13 +325,13 @@ BOOST_AUTO_TEST_CASE(test_get_toml_local_datetime)
t.tm_sec = 45; t.tm_sec = 45;
t.tm_isdst = -1; t.tm_isdst = -1;
const auto c = std::mktime(&t); const auto c = std::mktime(&t);
BOOST_CHECK_EQUAL(c, date); BOOST_TEST(c == date);
} }
BOOST_AUTO_TEST_CASE(test_get_toml_offset_datetime) BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_offset_datetime, value_type, test_value_types)
{ {
{ {
toml::value v1(toml::offset_datetime( value_type v1(toml::offset_datetime(
toml::local_date{2018, toml::month_t::Apr, 1}, toml::local_date{2018, toml::month_t::Apr, 1},
toml::local_time{12, 30, 0}, toml::local_time{12, 30, 0},
toml::time_offset{9, 0})); toml::time_offset{9, 0}));
@@ -351,18 +343,18 @@ BOOST_AUTO_TEST_CASE(test_get_toml_offset_datetime)
// get time_t as gmtime (2018-04-01T03:30:00Z) // get time_t as gmtime (2018-04-01T03:30:00Z)
const auto tmp = std::gmtime(std::addressof(timet)); // XXX not threadsafe! const auto tmp = std::gmtime(std::addressof(timet)); // XXX not threadsafe!
BOOST_CHECK(tmp); BOOST_TEST(tmp);
const auto tm = *tmp; const auto tm = *tmp;
BOOST_CHECK_EQUAL(tm.tm_year + 1900, 2018); BOOST_TEST(tm.tm_year + 1900 == 2018);
BOOST_CHECK_EQUAL(tm.tm_mon + 1, 4); BOOST_TEST(tm.tm_mon + 1 == 4);
BOOST_CHECK_EQUAL(tm.tm_mday, 1); BOOST_TEST(tm.tm_mday == 1);
BOOST_CHECK_EQUAL(tm.tm_hour, 3); BOOST_TEST(tm.tm_hour == 3);
BOOST_CHECK_EQUAL(tm.tm_min, 30); BOOST_TEST(tm.tm_min == 30);
BOOST_CHECK_EQUAL(tm.tm_sec, 0); BOOST_TEST(tm.tm_sec == 0);
} }
{ {
toml::value v1(toml::offset_datetime( value_type v1(toml::offset_datetime(
toml::local_date{2018, toml::month_t::Apr, 1}, toml::local_date{2018, toml::month_t::Apr, 1},
toml::local_time{12, 30, 0}, toml::local_time{12, 30, 0},
toml::time_offset{-8, 0})); toml::time_offset{-8, 0}));
@@ -374,14 +366,14 @@ BOOST_AUTO_TEST_CASE(test_get_toml_offset_datetime)
// get time_t as gmtime (2018-04-01T03:30:00Z) // get time_t as gmtime (2018-04-01T03:30:00Z)
const auto tmp = std::gmtime(std::addressof(timet)); // XXX not threadsafe! const auto tmp = std::gmtime(std::addressof(timet)); // XXX not threadsafe!
BOOST_CHECK(tmp); BOOST_TEST(tmp);
const auto tm = *tmp; const auto tm = *tmp;
BOOST_CHECK_EQUAL(tm.tm_year + 1900, 2018); BOOST_TEST(tm.tm_year + 1900 == 2018);
BOOST_CHECK_EQUAL(tm.tm_mon + 1, 4); BOOST_TEST(tm.tm_mon + 1 == 4);
BOOST_CHECK_EQUAL(tm.tm_mday, 1); BOOST_TEST(tm.tm_mday == 1);
BOOST_CHECK_EQUAL(tm.tm_hour, 20); BOOST_TEST(tm.tm_hour == 20);
BOOST_CHECK_EQUAL(tm.tm_min, 30); BOOST_TEST(tm.tm_min == 30);
BOOST_CHECK_EQUAL(tm.tm_sec, 0); BOOST_TEST(tm.tm_sec == 0);
} }
} }

72
tests/test_traits.cpp
View File

@@ -37,48 +37,48 @@ typedef std::unordered_map<std::string, dummy_type> std_unordered_map_type;
BOOST_AUTO_TEST_CASE(test_has_xxx) BOOST_AUTO_TEST_CASE(test_has_xxx)
{ {
BOOST_CHECK(toml::detail::has_iterator<std::list<dummy_type>>::value); BOOST_TEST(toml::detail::has_iterator<std::list<dummy_type>>::value);
BOOST_CHECK(toml::detail::has_iterator<std::forward_list<dummy_type>>::value); BOOST_TEST(toml::detail::has_iterator<std::forward_list<dummy_type>>::value);
BOOST_CHECK(toml::detail::has_iterator<std::deque<dummy_type>>::value); BOOST_TEST(toml::detail::has_iterator<std::deque<dummy_type>>::value);
BOOST_CHECK(toml::detail::has_iterator<std::vector<dummy_type>>::value); BOOST_TEST(toml::detail::has_iterator<std::vector<dummy_type>>::value);
BOOST_CHECK(toml::detail::has_iterator<std::set<dummy_type>>::value); BOOST_TEST(toml::detail::has_iterator<std::set<dummy_type>>::value);
BOOST_CHECK(toml::detail::has_iterator<std::unordered_set<std::string>>::value); BOOST_TEST(toml::detail::has_iterator<std::unordered_set<std::string>>::value);
BOOST_CHECK(toml::detail::has_iterator<std_array_type>::value); BOOST_TEST(toml::detail::has_iterator<std_array_type>::value);
BOOST_CHECK(toml::detail::has_iterator<std_map_type>::value); BOOST_TEST(toml::detail::has_iterator<std_map_type>::value);
BOOST_CHECK(toml::detail::has_iterator<std_unordered_map_type>::value); BOOST_TEST(toml::detail::has_iterator<std_unordered_map_type>::value);
BOOST_CHECK(toml::detail::has_iterator<dummy_container<dummy_type>>::value); BOOST_TEST(toml::detail::has_iterator<dummy_container<dummy_type>>::value);
BOOST_CHECK(toml::detail::has_value_type<std::list<dummy_type>>::value); BOOST_TEST(toml::detail::has_value_type<std::list<dummy_type>>::value);
BOOST_CHECK(toml::detail::has_value_type<std::forward_list<dummy_type>>::value); BOOST_TEST(toml::detail::has_value_type<std::forward_list<dummy_type>>::value);
BOOST_CHECK(toml::detail::has_value_type<std::deque<dummy_type>>::value); BOOST_TEST(toml::detail::has_value_type<std::deque<dummy_type>>::value);
BOOST_CHECK(toml::detail::has_value_type<std::vector<dummy_type>>::value); BOOST_TEST(toml::detail::has_value_type<std::vector<dummy_type>>::value);
BOOST_CHECK(toml::detail::has_value_type<std_array_type>::value); BOOST_TEST(toml::detail::has_value_type<std_array_type>::value);
BOOST_CHECK(toml::detail::has_value_type<std::set<dummy_type>>::value); BOOST_TEST(toml::detail::has_value_type<std::set<dummy_type>>::value);
BOOST_CHECK(toml::detail::has_value_type<std::unordered_set<std::string>>::value); BOOST_TEST(toml::detail::has_value_type<std::unordered_set<std::string>>::value);
BOOST_CHECK(toml::detail::has_value_type<std_map_type>::value); BOOST_TEST(toml::detail::has_value_type<std_map_type>::value);
BOOST_CHECK(toml::detail::has_value_type<std_unordered_map_type>::value); BOOST_TEST(toml::detail::has_value_type<std_unordered_map_type>::value);
BOOST_CHECK(toml::detail::has_value_type<dummy_container<dummy_type>>::value); BOOST_TEST(toml::detail::has_value_type<dummy_container<dummy_type>>::value);
BOOST_CHECK(toml::detail::has_key_type<std_map_type>::value); BOOST_TEST(toml::detail::has_key_type<std_map_type>::value);
BOOST_CHECK(toml::detail::has_key_type<std_unordered_map_type>::value); BOOST_TEST(toml::detail::has_key_type<std_unordered_map_type>::value);
BOOST_CHECK(toml::detail::has_mapped_type<std_map_type>::value); BOOST_TEST(toml::detail::has_mapped_type<std_map_type>::value);
BOOST_CHECK(toml::detail::has_mapped_type<std_unordered_map_type>::value); BOOST_TEST(toml::detail::has_mapped_type<std_unordered_map_type>::value);
} }
BOOST_AUTO_TEST_CASE(test_is_xxx) BOOST_AUTO_TEST_CASE(test_is_xxx)
{ {
BOOST_CHECK(toml::detail::is_container<std::list<dummy_type>>::value); BOOST_TEST(toml::detail::is_container<std::list<dummy_type>>::value);
BOOST_CHECK(toml::detail::is_container<std::forward_list<dummy_type>>::value); BOOST_TEST(toml::detail::is_container<std::forward_list<dummy_type>>::value);
BOOST_CHECK(toml::detail::is_container<std::deque<dummy_type>>::value); BOOST_TEST(toml::detail::is_container<std::deque<dummy_type>>::value);
BOOST_CHECK(toml::detail::is_container<std::vector<dummy_type>>::value); BOOST_TEST(toml::detail::is_container<std::vector<dummy_type>>::value);
BOOST_CHECK(toml::detail::is_container<std_array_type>::value); BOOST_TEST(toml::detail::is_container<std_array_type>::value);
BOOST_CHECK(toml::detail::is_container<std::set<dummy_type>>::value); BOOST_TEST(toml::detail::is_container<std::set<dummy_type>>::value);
BOOST_CHECK(toml::detail::is_container<std::unordered_set<std::string>>::value); BOOST_TEST(toml::detail::is_container<std::unordered_set<std::string>>::value);
BOOST_CHECK(toml::detail::is_container<dummy_container<dummy_type>>::value); BOOST_TEST(toml::detail::is_container<dummy_container<dummy_type>>::value);
BOOST_CHECK(!toml::detail::is_container<std_map_type>::value); BOOST_TEST(!toml::detail::is_container<std_map_type>::value);
BOOST_CHECK(!toml::detail::is_container<std_unordered_map_type>::value); BOOST_TEST(!toml::detail::is_container<std_unordered_map_type>::value);
BOOST_CHECK(toml::detail::is_map<std_map_type>::value); BOOST_TEST(toml::detail::is_map<std_map_type>::value);
BOOST_CHECK(toml::detail::is_map<std_unordered_map_type>::value); BOOST_TEST(toml::detail::is_map<std_unordered_map_type>::value);
} }

46
tests/test_utility.cpp
View File

@@ -14,69 +14,39 @@ BOOST_AUTO_TEST_CASE(test_resize)
{ {
typedef std::vector<int> resizable_type; typedef std::vector<int> resizable_type;
typedef std::array<int,1> non_resizable_type; typedef std::array<int,1> non_resizable_type;
BOOST_CHECK(toml::detail::has_resize_method<resizable_type>::value); BOOST_TEST(toml::detail::has_resize_method<resizable_type>::value);
BOOST_CHECK(!toml::detail::has_resize_method<non_resizable_type>::value); BOOST_TEST(!toml::detail::has_resize_method<non_resizable_type>::value);
} }
{ {
bool thrown = false;
std::vector<int> v; std::vector<int> v;
try
{
toml::resize(v, 10); toml::resize(v, 10);
BOOST_TEST(v.size() == 10u);
} }
catch(std::exception& ex)
{ {
thrown = true;
}
BOOST_CHECK(!thrown);
BOOST_CHECK_EQUAL(v.size(), 10u);
}
{
bool thrown = false;
std::array<int, 15> a; std::array<int, 15> a;
try
{
toml::resize(a, 10); toml::resize(a, 10);
BOOST_TEST(a.size() == 15u);
} }
catch(std::exception& ex)
{ {
thrown = true;
}
BOOST_CHECK(!thrown);
BOOST_CHECK_EQUAL(a.size(), 15u);
}
{
bool thrown = false;
std::array<int, 15> a; std::array<int, 15> a;
try BOOST_CHECK_THROW(toml::resize(a, 20), std::invalid_argument);
{
toml::resize(a, 20);
}
catch(std::exception& ex)
{
thrown = true;
}
BOOST_CHECK(thrown);
} }
} }
BOOST_AUTO_TEST_CASE(test_concat_to_string) BOOST_AUTO_TEST_CASE(test_concat_to_string)
{ {
const std::string cat = toml::concat_to_string("foo", "bar", 42); const std::string cat = toml::concat_to_string("foo", "bar", 42);
BOOST_CHECK(cat == "foobar42"); BOOST_TEST(cat == "foobar42");
} }
BOOST_AUTO_TEST_CASE(test_from_string) BOOST_AUTO_TEST_CASE(test_from_string)
{ {
{ {
const std::string str("123"); const std::string str("123");
BOOST_CHECK_EQUAL(toml::from_string<int>(str, 0), 123); BOOST_TEST(toml::from_string<int>(str, 0) == 123);
} }
{ {
const std::string str("01"); const std::string str("01");
BOOST_CHECK_EQUAL(toml::from_string<int>(str, 0), 1); BOOST_TEST(toml::from_string<int>(str, 0) == 1);
} }
} }