From 5a20d55dd0d37d7e81e2a50af1fd2761883585ec Mon Sep 17 00:00:00 2001 From: ToruNiina Date: Wed, 12 Dec 2018 17:23:06 +0900 Subject: [PATCH] add test for toml::get --- tests/CMakeLists.txt | 2 +- tests/test_get.cpp | 318 +++++++++++++++++++++++++++++++------------ 2 files changed, 230 insertions(+), 90 deletions(-) diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 0c6c6b8..977382e 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -18,10 +18,10 @@ set(TEST_NAMES test_parse_inline_table test_parse_key test_parse_table_key + test_get # test_to_toml # test_from_toml -# test_get # test_get_or # test_parser # test_parse_file diff --git a/tests/test_get.cpp b/tests/test_get.cpp index 728efab..56d0929 100644 --- a/tests/test_get.cpp +++ b/tests/test_get.cpp @@ -5,7 +5,8 @@ #define BOOST_TEST_NO_LIB #include #endif -#include +#include +#include #include #include #include @@ -15,98 +16,237 @@ BOOST_AUTO_TEST_CASE(test_get_exact) { - toml::Boolean b(true); - toml::Integer i(42); - toml::Float f(3.14); - toml::String s("hoge"); - toml::Array a; - a.emplace_back(2); - a.emplace_back(7); - a.emplace_back(1); - a.emplace_back(8); - a.emplace_back(2); - toml::Table t; - t.emplace("val1", true); - t.emplace("val2", 42); - t.emplace("val3", 3.14); - t.emplace("val4", "piyo"); + { + toml::value v(true); + BOOST_CHECK_EQUAL(true, toml::get(v)); - toml::value v1(b); - toml::value v2(i); - toml::value v3(f); - toml::value v4(s); - toml::value v6(a); - toml::value v7(t); + toml::get(v) = false; + BOOST_CHECK_EQUAL(false, toml::get(v)); + } + { + toml::value v(42); + BOOST_CHECK_EQUAL(toml::integer(42), toml::get(v)); - toml::Boolean u1 = toml::get(v1); - toml::Integer u2 = toml::get(v2); - toml::Float u3 = toml::get(v3); - toml::String u4 = toml::get(v4); - toml::Array u6 = toml::get(v6); - toml::Table u7 = toml::get(v7); + toml::get(v) = 54; + BOOST_CHECK_EQUAL(toml::integer(54), toml::get(v)); + } + { + toml::value v(3.14); + BOOST_CHECK_EQUAL(toml::floating(3.14), toml::get(v)); - BOOST_CHECK_EQUAL(u1, b); - BOOST_CHECK_EQUAL(u2, i); - BOOST_CHECK_EQUAL(u3, f); - BOOST_CHECK_EQUAL(u4, s); - BOOST_CHECK_EQUAL(u6.at(0).cast(), a.at(0).cast()); - BOOST_CHECK_EQUAL(u6.at(1).cast(), a.at(1).cast()); - BOOST_CHECK_EQUAL(u6.at(2).cast(), a.at(2).cast()); - BOOST_CHECK_EQUAL(u6.at(3).cast(), a.at(3).cast()); - BOOST_CHECK_EQUAL(u6.at(4).cast(), a.at(4).cast()); - BOOST_CHECK_EQUAL(u7.at("val1").cast(), true); - BOOST_CHECK_EQUAL(u7.at("val2").cast(), 42); - BOOST_CHECK_CLOSE_FRACTION(u7.at("val3").cast(),3.14, 1e-3); - BOOST_CHECK_EQUAL(u7.at("val4").cast(), "piyo"); + toml::get(v) = 2.71; + BOOST_CHECK_EQUAL(toml::floating(2.71), toml::get(v)); + } + { + toml::value v("foo"); + BOOST_CHECK_EQUAL(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), + toml::get(v)); + } + { + toml::value v("foo", toml::string_t::literal); + BOOST_CHECK_EQUAL(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), + toml::get(v)); + } + { + toml::local_date d(2018, toml::month_t::Apr, 22); + toml::value v(d); + BOOST_CHECK(d == toml::get(v)); + + toml::get(v).year = 2017; + d.year = 2017; + BOOST_CHECK(d == toml::get(v)); + } + { + toml::local_time t(12, 30, 45); + toml::value v(t); + BOOST_CHECK(t == toml::get(v)); + + toml::get(v).hour = 9; + t.hour = 9; + BOOST_CHECK(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)); + + toml::get(v).date.year = 2017; + dt.date.year = 2017; + BOOST_CHECK(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)); + + toml::get(v).date.year = 2017; + dt.date.year = 2017; + BOOST_CHECK(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)); + + toml::get(v).push_back(toml::value(123)); + vec.push_back(toml::value(123)); + BOOST_CHECK(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)); + + toml::get(v)["key3"] = toml::value(123); + tab["key3"] = toml::value(123); + BOOST_CHECK(tab == toml::get(v)); + } } - -BOOST_AUTO_TEST_CASE(test_get_cast) +BOOST_AUTO_TEST_CASE(test_get_integer_type) { - toml::Integer i(42); - toml::Float f(3.14); - toml::String s("hoge"); - toml::Datetime d(std::chrono::system_clock::now()); - toml::Array a; - a.emplace_back(2); - a.emplace_back(7); - a.emplace_back(1); - a.emplace_back(8); - a.emplace_back(2); - toml::Table t; - t.emplace("val1", true); - t.emplace("val2", 42); - t.emplace("val3", 3.14); - t.emplace("val4", "piyo"); - - toml::value v2(i); - toml::value v3(f); - toml::value v4(s); - toml::value v5(d); - toml::value v6(a); - toml::value v7(t); - - const auto u2 = toml::get(v2); - const auto u3 = toml::get(v3); - const auto u4 = toml::get>(v6); - const auto u5 = toml::get >(v6); - const auto u6 = toml::get>(v6); - std::map u7 = toml::get>(v7); - - std::deque r4{2,7,1,8,2}; - std::list r5{2,7,1,8,2}; - std::array r6{{2,7,1,8,2}}; - - BOOST_CHECK_EQUAL(u2, 42ul); - BOOST_CHECK_CLOSE_FRACTION(u3, 3.14, 1e-3); - const bool dq = r4 == u4; - const bool ls = r5 == u5; - const bool ar = r6 == u6; - BOOST_CHECK(dq); - BOOST_CHECK(ls); - BOOST_CHECK(ar); - BOOST_CHECK_EQUAL(u7.at("val1").cast(), true); - BOOST_CHECK_EQUAL(u7.at("val2").cast(), 42); - BOOST_CHECK_CLOSE_FRACTION(u7.at("val3").cast(),3.14, 1e-3); - BOOST_CHECK_EQUAL(u7.at("val4").cast(), "piyo"); + { + 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)); + } +} + +BOOST_AUTO_TEST_CASE(test_get_floating_type) +{ + { + 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)); + } +} + +BOOST_AUTO_TEST_CASE(test_get_string_type) +{ + { + toml::value v("foo", toml::string_t::basic); + BOOST_CHECK_EQUAL("foo", toml::get(v)); + toml::get(v) += "bar"; + BOOST_CHECK_EQUAL("foobar", toml::get(v)); + } + { + toml::value v("foo", toml::string_t::literal); + BOOST_CHECK_EQUAL("foo", toml::get(v)); + toml::get(v) += "bar"; + BOOST_CHECK_EQUAL("foobar", toml::get(v)); + } +} + +BOOST_AUTO_TEST_CASE(test_get_toml_array) +{ + 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 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)); + + 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_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)); + + 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)); + + 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)); + + toml::value p(toml::array{}); + toml::get(p).push_back(toml::value(3.14)); + toml::get(p).push_back(toml::value(2.71)); + std::pair pr = toml::get >(p); + BOOST_CHECK_EQUAL(3.14, pr.first); + BOOST_CHECK_EQUAL(2.71, pr.second); +} + +BOOST_AUTO_TEST_CASE(test_get_toml_array_of_array) +{ + 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; + + 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_CHECK_EQUAL(p.second.at(0), "foo"); + BOOST_CHECK_EQUAL(p.second.at(1), "bar"); + BOOST_CHECK_EQUAL(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_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"); }