From dd9b04ae3b8fb140b0f76b4665cfdce4f310b1b0 Mon Sep 17 00:00:00 2001 From: ToruNiina Date: Fri, 21 Jun 2019 15:00:41 +0900 Subject: [PATCH] fix: fix test case name --- tests/test_format_error.cpp | 2 +- tests/test_get.cpp | 338 ++++++++++++++++++------------------ tests/test_traits.cpp | 72 ++++---- tests/test_utility.cpp | 50 ++---- 4 files changed, 212 insertions(+), 250 deletions(-) diff --git a/tests/test_format_error.cpp b/tests/test_format_error.cpp index 23cdea5..7e6c290 100644 --- a/tests/test_format_error.cpp +++ b/tests/test_format_error.cpp @@ -1,4 +1,4 @@ -#define BOOST_TEST_MODULE "test_value" +#define BOOST_TEST_MODULE "test_format_error" #ifdef UNITTEST_FRAMEWORK_LIBRARY_EXIST #include #else diff --git a/tests/test_get.cpp b/tests/test_get.cpp index 833c479..df4297a 100644 --- a/tests/test_get.cpp +++ b/tests/test_get.cpp @@ -5,294 +5,284 @@ #define BOOST_TEST_NO_LIB #include #endif -#include -#include +#include #include #include #include #include #include +#include #if __cplusplus >= 201703L #include #endif +using test_value_types = std::tuple< + toml::value, + toml::basic_value, + toml::basic_value, + toml::basic_value +>; -BOOST_AUTO_TEST_CASE(test_get_exact) +BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types) { { - toml::value v(true); - BOOST_CHECK_EQUAL(true, toml::get(v)); + value_type v(true); + BOOST_TEST(true == toml::get(v)); toml::get(v) = false; - BOOST_CHECK_EQUAL(false, toml::get(v)); + BOOST_TEST(false == toml::get(v)); } { - toml::value v(42); - BOOST_CHECK_EQUAL(toml::integer(42), toml::get(v)); + value_type v(42); + BOOST_TEST(toml::integer(42) == toml::get(v)); toml::get(v) = 54; - BOOST_CHECK_EQUAL(toml::integer(54), toml::get(v)); + BOOST_TEST(toml::integer(54) == toml::get(v)); } { - toml::value v(3.14); - BOOST_CHECK_EQUAL(toml::floating(3.14), toml::get(v)); + value_type v(3.14); + BOOST_TEST(toml::floating(3.14) == toml::get(v)); toml::get(v) = 2.71; - BOOST_CHECK_EQUAL(toml::floating(2.71), toml::get(v)); + BOOST_TEST(toml::floating(2.71) == toml::get(v)); } { - toml::value v("foo"); - BOOST_CHECK_EQUAL(toml::string("foo", toml::string_t::basic), + value_type v("foo"); + BOOST_TEST(toml::string("foo", toml::string_t::basic) == toml::get(v)); toml::get(v).str += "bar"; - BOOST_CHECK_EQUAL(toml::string("foobar", toml::string_t::basic), + BOOST_TEST(toml::string("foobar", toml::string_t::basic) == toml::get(v)); } { - toml::value v("foo", toml::string_t::literal); - BOOST_CHECK_EQUAL(toml::string("foo", toml::string_t::literal), + value_type v("foo", toml::string_t::literal); + BOOST_TEST(toml::string("foo", toml::string_t::literal) == toml::get(v)); toml::get(v).str += "bar"; - BOOST_CHECK_EQUAL(toml::string("foobar", toml::string_t::literal), + BOOST_TEST(toml::string("foobar", toml::string_t::literal) == toml::get(v)); } { toml::local_date d(2018, toml::month_t::Apr, 22); - toml::value v(d); - BOOST_CHECK(d == toml::get(v)); + value_type v(d); + BOOST_TEST(d == toml::get(v)); toml::get(v).year = 2017; d.year = 2017; - BOOST_CHECK(d == toml::get(v)); + BOOST_TEST(d == toml::get(v)); } { toml::local_time t(12, 30, 45); - toml::value v(t); - BOOST_CHECK(t == toml::get(v)); + value_type v(t); + BOOST_TEST(t == toml::get(v)); toml::get(v).hour = 9; t.hour = 9; - BOOST_CHECK(t == toml::get(v)); + BOOST_TEST(t == toml::get(v)); } { toml::local_datetime dt(toml::local_date(2018, toml::month_t::Apr, 22), toml::local_time(12, 30, 45)); - toml::value v(dt); - BOOST_CHECK(dt == toml::get(v)); + value_type v(dt); + BOOST_TEST(dt == toml::get(v)); toml::get(v).date.year = 2017; dt.date.year = 2017; - BOOST_CHECK(dt == toml::get(v)); + BOOST_TEST(dt == toml::get(v)); } { toml::offset_datetime dt(toml::local_datetime( toml::local_date(2018, toml::month_t::Apr, 22), toml::local_time(12, 30, 45)), toml::time_offset(9, 0)); - toml::value v(dt); - BOOST_CHECK(dt == toml::get(v)); + value_type v(dt); + BOOST_TEST(dt == toml::get(v)); toml::get(v).date.year = 2017; dt.date.year = 2017; - BOOST_CHECK(dt == toml::get(v)); + BOOST_TEST(dt == toml::get(v)); } { - toml::array vec; - vec.push_back(toml::value(42)); - vec.push_back(toml::value(54)); - toml::value v(vec); - BOOST_CHECK(vec == toml::get(v)); + using array_type = typename value_type::array_type; + array_type vec; + vec.push_back(value_type(42)); + vec.push_back(value_type(54)); + value_type v(vec); + BOOST_TEST(vec == toml::get(v)); - toml::get(v).push_back(toml::value(123)); - vec.push_back(toml::value(123)); - BOOST_CHECK(vec == toml::get(v)); + toml::get(v).push_back(value_type(123)); + vec.push_back(value_type(123)); + BOOST_TEST(vec == toml::get(v)); } { - toml::table tab; - tab["key1"] = toml::value(42); - tab["key2"] = toml::value(3.14); - toml::value v(tab); - BOOST_CHECK(tab == toml::get(v)); + using table_type = typename value_type::table_type; + table_type tab; + tab["key1"] = value_type(42); + tab["key2"] = value_type(3.14); + value_type v(tab); + BOOST_TEST(tab == toml::get(v)); - toml::get(v)["key3"] = toml::value(123); - tab["key3"] = toml::value(123); - BOOST_CHECK(tab == toml::get(v)); + toml::get(v)["key3"] = value_type(123); + tab["key3"] = value_type(123); + BOOST_TEST(tab == toml::get(v)); } { - toml::value v1(42); - BOOST_CHECK(v1 == toml::get(v1)); + value_type v1(42); + BOOST_TEST(v1 == toml::get(v1)); - toml::value v2(54); - toml::get(v1) = v2; - BOOST_CHECK(v2 == toml::get(v1)); + value_type v2(54); + toml::get(v1) = v2; + BOOST_TEST(v2 == toml::get(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); - BOOST_CHECK_EQUAL(int(42), toml::get(v)); - BOOST_CHECK_EQUAL(short(42), toml::get(v)); - BOOST_CHECK_EQUAL(char(42), toml::get(v)); - BOOST_CHECK_EQUAL(unsigned(42), toml::get(v)); - BOOST_CHECK_EQUAL(long(42), toml::get(v)); - BOOST_CHECK_EQUAL(std::int64_t(42), toml::get(v)); - BOOST_CHECK_EQUAL(std::uint64_t(42), toml::get(v)); - BOOST_CHECK_EQUAL(std::int16_t(42), toml::get(v)); - BOOST_CHECK_EQUAL(std::uint16_t(42), toml::get(v)); + value_type v(42); + BOOST_TEST(int(42) == toml::get(v)); + BOOST_TEST(short(42) == toml::get(v)); + BOOST_TEST(char(42) == toml::get(v)); + BOOST_TEST(unsigned(42) == toml::get(v)); + BOOST_TEST(long(42) == toml::get(v)); + BOOST_TEST(std::int64_t(42) == toml::get(v)); + BOOST_TEST(std::uint64_t(42) == toml::get(v)); + BOOST_TEST(std::int16_t(42) == toml::get(v)); + BOOST_TEST(std::uint16_t(42) == toml::get(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); - BOOST_CHECK_EQUAL(static_cast(3.14), toml::get(v)); - BOOST_CHECK_EQUAL(static_cast(3.14), toml::get(v)); - BOOST_CHECK_EQUAL(static_cast(3.14), toml::get(v)); + value_type v(3.14); + BOOST_TEST(static_cast(3.14) == toml::get(v)); + BOOST_TEST(static_cast(3.14) == toml::get(v)); + BOOST_TEST(static_cast(3.14) == toml::get(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); - BOOST_CHECK_EQUAL("foo", toml::get(v)); + value_type v("foo", toml::string_t::basic); + BOOST_TEST("foo" == toml::get(v)); toml::get(v) += "bar"; - BOOST_CHECK_EQUAL("foobar", toml::get(v)); + BOOST_TEST("foobar" == toml::get(v)); } { - toml::value v("foo", toml::string_t::literal); - BOOST_CHECK_EQUAL("foo", toml::get(v)); + value_type v("foo", toml::string_t::literal); + BOOST_TEST("foo" == toml::get(v)); toml::get(v) += "bar"; - BOOST_CHECK_EQUAL("foobar", toml::get(v)); + BOOST_TEST("foobar" == toml::get(v)); } #if __cplusplus >= 201703L { - toml::value v("foo", toml::string_t::basic); - BOOST_CHECK_EQUAL("foo", toml::get(v)); + value_type v("foo", toml::string_t::basic); + BOOST_TEST("foo" == toml::get(v)); } { - toml::value v("foo", toml::string_t::literal); - BOOST_CHECK_EQUAL("foo", toml::get(v)); + value_type v("foo", toml::string_t::literal); + BOOST_TEST("foo" == toml::get(v)); } #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)); - toml::get(v).push_back(toml::value(42)); - toml::get(v).push_back(toml::value(54)); - toml::get(v).push_back(toml::value(69)); - toml::get(v).push_back(toml::value(72)); + const value_type v{42, 54, 69, 72}; const std::vector vec = toml::get>(v); const std::list lst = toml::get>(v); const std::deque deq = toml::get>(v); - BOOST_CHECK_EQUAL(42, vec.at(0)); - BOOST_CHECK_EQUAL(54, vec.at(1)); - BOOST_CHECK_EQUAL(69, vec.at(2)); - BOOST_CHECK_EQUAL(72, vec.at(3)); + BOOST_TEST(42 == vec.at(0)); + BOOST_TEST(54 == vec.at(1)); + BOOST_TEST(69 == vec.at(2)); + BOOST_TEST(72 == vec.at(3)); std::list::const_iterator iter = lst.begin(); - BOOST_CHECK_EQUAL(static_cast(42), *(iter++)); - BOOST_CHECK_EQUAL(static_cast(54), *(iter++)); - BOOST_CHECK_EQUAL(static_cast(69), *(iter++)); - BOOST_CHECK_EQUAL(static_cast(72), *(iter++)); + BOOST_TEST(static_cast(42) == *(iter++)); + BOOST_TEST(static_cast(54) == *(iter++)); + BOOST_TEST(static_cast(69) == *(iter++)); + BOOST_TEST(static_cast(72) == *(iter++)); - BOOST_CHECK_EQUAL(static_cast(42), deq.at(0)); - BOOST_CHECK_EQUAL(static_cast(54), deq.at(1)); - BOOST_CHECK_EQUAL(static_cast(69), deq.at(2)); - BOOST_CHECK_EQUAL(static_cast(72), deq.at(3)); + BOOST_TEST(static_cast(42) == deq.at(0)); + BOOST_TEST(static_cast(54) == deq.at(1)); + BOOST_TEST(static_cast(69) == deq.at(2)); + BOOST_TEST(static_cast(72) == deq.at(3)); std::array ary = toml::get>(v); - BOOST_CHECK_EQUAL(static_cast(42), ary.at(0)); - BOOST_CHECK_EQUAL(static_cast(54), ary.at(1)); - BOOST_CHECK_EQUAL(static_cast(69), ary.at(2)); - BOOST_CHECK_EQUAL(static_cast(72), ary.at(3)); + BOOST_TEST(static_cast(42) == ary.at(0)); + BOOST_TEST(static_cast(54) == ary.at(1)); + BOOST_TEST(static_cast(69) == ary.at(2)); + BOOST_TEST(static_cast(72) == ary.at(3)); std::tuple tpl = toml::get>(v); - BOOST_CHECK_EQUAL(static_cast(42), std::get<0>(tpl)); - BOOST_CHECK_EQUAL(static_cast(54), std::get<1>(tpl)); - BOOST_CHECK_EQUAL(static_cast(69), std::get<2>(tpl)); - BOOST_CHECK_EQUAL(static_cast(72), std::get<3>(tpl)); + BOOST_TEST(static_cast(42) == std::get<0>(tpl)); + BOOST_TEST(static_cast(54) == std::get<1>(tpl)); + BOOST_TEST(static_cast(69) == std::get<2>(tpl)); + BOOST_TEST(static_cast(72) == std::get<3>(tpl)); - toml::value p(toml::array{}); - toml::get(p).push_back(toml::value(3.14)); - toml::get(p).push_back(toml::value(2.71)); + const value_type p{3.14, 2.71}; std::pair pr = toml::get >(p); - BOOST_CHECK_EQUAL(3.14, pr.first); - BOOST_CHECK_EQUAL(2.71, pr.second); + BOOST_TEST(3.14 == pr.first); + 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{}); - toml::get(v1).push_back(toml::value(42)); - toml::get(v1).push_back(toml::value(54)); - toml::get(v1).push_back(toml::value(69)); - toml::get(v1).push_back(toml::value(72)); - - toml::value v2(toml::array{}); - toml::get(v2).push_back(toml::value("foo")); - toml::get(v2).push_back(toml::value("bar")); - toml::get(v2).push_back(toml::value("baz")); - - toml::value v(toml::array(2)); - toml::get(v).at(0) = v1; - toml::get(v).at(1) = v2; + const value_type v1{42, 54, 69, 72}; + const value_type v2{"foo", "bar", "baz"}; + const value_type v{v1, v2}; std::pair, std::vector> p = toml::get, std::vector>>(v); - BOOST_CHECK_EQUAL(p.first.at(0), 42); - BOOST_CHECK_EQUAL(p.first.at(1), 54); - BOOST_CHECK_EQUAL(p.first.at(2), 69); - BOOST_CHECK_EQUAL(p.first.at(3), 72); + BOOST_TEST(p.first.at(0) == 42); + BOOST_TEST(p.first.at(1) == 54); + BOOST_TEST(p.first.at(2) == 69); + BOOST_TEST(p.first.at(3) == 72); - BOOST_CHECK_EQUAL(p.second.at(0), "foo"); - BOOST_CHECK_EQUAL(p.second.at(1), "bar"); - BOOST_CHECK_EQUAL(p.second.at(2), "baz"); + BOOST_TEST(p.second.at(0) == "foo"); + BOOST_TEST(p.second.at(1) == "bar"); + BOOST_TEST(p.second.at(2) == "baz"); std::tuple, std::vector> t = toml::get, std::vector>>(v); - BOOST_CHECK_EQUAL(std::get<0>(t).at(0), 42); - BOOST_CHECK_EQUAL(std::get<0>(t).at(1), 54); - BOOST_CHECK_EQUAL(std::get<0>(t).at(2), 69); - BOOST_CHECK_EQUAL(std::get<0>(t).at(3), 72); + BOOST_TEST(std::get<0>(t).at(0) == 42); + BOOST_TEST(std::get<0>(t).at(1) == 54); + BOOST_TEST(std::get<0>(t).at(2) == 69); + BOOST_TEST(std::get<0>(t).at(3) == 72); - BOOST_CHECK_EQUAL(std::get<1>(t).at(0), "foo"); - BOOST_CHECK_EQUAL(std::get<1>(t).at(1), "bar"); - BOOST_CHECK_EQUAL(std::get<1>(t).at(2), "baz"); + BOOST_TEST(std::get<1>(t).at(0) == "foo"); + BOOST_TEST(std::get<1>(t).at(1) == "bar"); + 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}, {"key2", 2}, {"key3", 3}, {"key4", 4} - }); + }; const auto v = toml::get>(v1); - BOOST_CHECK_EQUAL(v.at("key1"), 1); - BOOST_CHECK_EQUAL(v.at("key2"), 2); - BOOST_CHECK_EQUAL(v.at("key3"), 3); - BOOST_CHECK_EQUAL(v.at("key4"), 4); + BOOST_TEST(v.at("key1") == 1); + BOOST_TEST(v.at("key2") == 2); + BOOST_TEST(v.at("key3") == 3); + BOOST_TEST(v.at("key4") == 4); } - -BOOST_AUTO_TEST_CASE(test_get_toml_local_date) +BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_local_date, value_type, test_value_types) { - 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( toml::get(v1)); @@ -305,20 +295,22 @@ BOOST_AUTO_TEST_CASE(test_get_toml_local_date) t.tm_sec = 0; t.tm_isdst = -1; 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(v1); - BOOST_CHECK(time == std::chrono::hours(12) + - std::chrono::minutes(30) + std::chrono::seconds(45)); + const bool result = time == std::chrono::hours(12) + + 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_time{12, 30, 45})); @@ -333,13 +325,13 @@ BOOST_AUTO_TEST_CASE(test_get_toml_local_datetime) t.tm_sec = 45; t.tm_isdst = -1; 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_time{12, 30, 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) const auto tmp = std::gmtime(std::addressof(timet)); // XXX not threadsafe! - BOOST_CHECK(tmp); + BOOST_TEST(tmp); const auto tm = *tmp; - BOOST_CHECK_EQUAL(tm.tm_year + 1900, 2018); - BOOST_CHECK_EQUAL(tm.tm_mon + 1, 4); - BOOST_CHECK_EQUAL(tm.tm_mday, 1); - BOOST_CHECK_EQUAL(tm.tm_hour, 3); - BOOST_CHECK_EQUAL(tm.tm_min, 30); - BOOST_CHECK_EQUAL(tm.tm_sec, 0); + BOOST_TEST(tm.tm_year + 1900 == 2018); + BOOST_TEST(tm.tm_mon + 1 == 4); + BOOST_TEST(tm.tm_mday == 1); + BOOST_TEST(tm.tm_hour == 3); + BOOST_TEST(tm.tm_min == 30); + 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_time{12, 30, 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) const auto tmp = std::gmtime(std::addressof(timet)); // XXX not threadsafe! - BOOST_CHECK(tmp); + BOOST_TEST(tmp); const auto tm = *tmp; - BOOST_CHECK_EQUAL(tm.tm_year + 1900, 2018); - BOOST_CHECK_EQUAL(tm.tm_mon + 1, 4); - BOOST_CHECK_EQUAL(tm.tm_mday, 1); - BOOST_CHECK_EQUAL(tm.tm_hour, 20); - BOOST_CHECK_EQUAL(tm.tm_min, 30); - BOOST_CHECK_EQUAL(tm.tm_sec, 0); + BOOST_TEST(tm.tm_year + 1900 == 2018); + BOOST_TEST(tm.tm_mon + 1 == 4); + BOOST_TEST(tm.tm_mday == 1); + BOOST_TEST(tm.tm_hour == 20); + BOOST_TEST(tm.tm_min == 30); + BOOST_TEST(tm.tm_sec == 0); } } diff --git a/tests/test_traits.cpp b/tests/test_traits.cpp index 70521ea..63b8a14 100644 --- a/tests/test_traits.cpp +++ b/tests/test_traits.cpp @@ -37,48 +37,48 @@ typedef std::unordered_map std_unordered_map_type; BOOST_AUTO_TEST_CASE(test_has_xxx) { - BOOST_CHECK(toml::detail::has_iterator>::value); - BOOST_CHECK(toml::detail::has_iterator>::value); - BOOST_CHECK(toml::detail::has_iterator>::value); - BOOST_CHECK(toml::detail::has_iterator>::value); - BOOST_CHECK(toml::detail::has_iterator>::value); - BOOST_CHECK(toml::detail::has_iterator>::value); - BOOST_CHECK(toml::detail::has_iterator::value); - BOOST_CHECK(toml::detail::has_iterator::value); - BOOST_CHECK(toml::detail::has_iterator::value); - BOOST_CHECK(toml::detail::has_iterator>::value); + BOOST_TEST(toml::detail::has_iterator>::value); + BOOST_TEST(toml::detail::has_iterator>::value); + BOOST_TEST(toml::detail::has_iterator>::value); + BOOST_TEST(toml::detail::has_iterator>::value); + BOOST_TEST(toml::detail::has_iterator>::value); + BOOST_TEST(toml::detail::has_iterator>::value); + BOOST_TEST(toml::detail::has_iterator::value); + BOOST_TEST(toml::detail::has_iterator::value); + BOOST_TEST(toml::detail::has_iterator::value); + BOOST_TEST(toml::detail::has_iterator>::value); - BOOST_CHECK(toml::detail::has_value_type>::value); - BOOST_CHECK(toml::detail::has_value_type>::value); - BOOST_CHECK(toml::detail::has_value_type>::value); - BOOST_CHECK(toml::detail::has_value_type>::value); - BOOST_CHECK(toml::detail::has_value_type::value); - BOOST_CHECK(toml::detail::has_value_type>::value); - BOOST_CHECK(toml::detail::has_value_type>::value); - BOOST_CHECK(toml::detail::has_value_type::value); - BOOST_CHECK(toml::detail::has_value_type::value); - BOOST_CHECK(toml::detail::has_value_type>::value); + BOOST_TEST(toml::detail::has_value_type>::value); + BOOST_TEST(toml::detail::has_value_type>::value); + BOOST_TEST(toml::detail::has_value_type>::value); + BOOST_TEST(toml::detail::has_value_type>::value); + BOOST_TEST(toml::detail::has_value_type::value); + BOOST_TEST(toml::detail::has_value_type>::value); + BOOST_TEST(toml::detail::has_value_type>::value); + BOOST_TEST(toml::detail::has_value_type::value); + BOOST_TEST(toml::detail::has_value_type::value); + BOOST_TEST(toml::detail::has_value_type>::value); - BOOST_CHECK(toml::detail::has_key_type::value); - BOOST_CHECK(toml::detail::has_key_type::value); - BOOST_CHECK(toml::detail::has_mapped_type::value); - BOOST_CHECK(toml::detail::has_mapped_type::value); + BOOST_TEST(toml::detail::has_key_type::value); + BOOST_TEST(toml::detail::has_key_type::value); + BOOST_TEST(toml::detail::has_mapped_type::value); + BOOST_TEST(toml::detail::has_mapped_type::value); } BOOST_AUTO_TEST_CASE(test_is_xxx) { - BOOST_CHECK(toml::detail::is_container>::value); - BOOST_CHECK(toml::detail::is_container>::value); - BOOST_CHECK(toml::detail::is_container>::value); - BOOST_CHECK(toml::detail::is_container>::value); - BOOST_CHECK(toml::detail::is_container::value); - BOOST_CHECK(toml::detail::is_container>::value); - BOOST_CHECK(toml::detail::is_container>::value); - BOOST_CHECK(toml::detail::is_container>::value); + BOOST_TEST(toml::detail::is_container>::value); + BOOST_TEST(toml::detail::is_container>::value); + BOOST_TEST(toml::detail::is_container>::value); + BOOST_TEST(toml::detail::is_container>::value); + BOOST_TEST(toml::detail::is_container::value); + BOOST_TEST(toml::detail::is_container>::value); + BOOST_TEST(toml::detail::is_container>::value); + BOOST_TEST(toml::detail::is_container>::value); - BOOST_CHECK(!toml::detail::is_container::value); - BOOST_CHECK(!toml::detail::is_container::value); + BOOST_TEST(!toml::detail::is_container::value); + BOOST_TEST(!toml::detail::is_container::value); - BOOST_CHECK(toml::detail::is_map::value); - BOOST_CHECK(toml::detail::is_map::value); + BOOST_TEST(toml::detail::is_map::value); + BOOST_TEST(toml::detail::is_map::value); } diff --git a/tests/test_utility.cpp b/tests/test_utility.cpp index b879c54..c4cb003 100644 --- a/tests/test_utility.cpp +++ b/tests/test_utility.cpp @@ -14,69 +14,39 @@ BOOST_AUTO_TEST_CASE(test_resize) { typedef std::vector resizable_type; typedef std::array non_resizable_type; - BOOST_CHECK(toml::detail::has_resize_method::value); - BOOST_CHECK(!toml::detail::has_resize_method::value); + BOOST_TEST(toml::detail::has_resize_method::value); + BOOST_TEST(!toml::detail::has_resize_method::value); } - { - bool thrown = false; std::vector v; - try - { - toml::resize(v, 10); - } - catch(std::exception& ex) - { - thrown = true; - } - BOOST_CHECK(!thrown); - BOOST_CHECK_EQUAL(v.size(), 10u); + toml::resize(v, 10); + BOOST_TEST(v.size() == 10u); } - { - bool thrown = false; std::array a; - try - { - toml::resize(a, 10); - } - catch(std::exception& ex) - { - thrown = true; - } - BOOST_CHECK(!thrown); - BOOST_CHECK_EQUAL(a.size(), 15u); + toml::resize(a, 10); + BOOST_TEST(a.size() == 15u); } - { - bool thrown = false; std::array a; - try - { - toml::resize(a, 20); - } - catch(std::exception& ex) - { - thrown = true; - } - BOOST_CHECK(thrown); + BOOST_CHECK_THROW(toml::resize(a, 20), std::invalid_argument); } } BOOST_AUTO_TEST_CASE(test_concat_to_string) { 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) { { const std::string str("123"); - BOOST_CHECK_EQUAL(toml::from_string(str, 0), 123); + BOOST_TEST(toml::from_string(str, 0) == 123); } { const std::string str("01"); - BOOST_CHECK_EQUAL(toml::from_string(str, 0), 1); + BOOST_TEST(toml::from_string(str, 0) == 1); } }