add test for toml::get

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

tests/test_get.cpp

@@ -5,7 +5,8 @@
 #define BOOST_TEST_NO_LIB
 #include <boost/test/included/unit_test.hpp>
 #endif
-#include <toml.hpp>
+#include <toml/value.hpp>
+#include <toml/get.hpp>
 #include <map>
 #include <unordered_map>
 #include <list>
@@ -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 v1(b);
-    toml::value v2(i);
-    toml::value v3(f);
-    toml::value v4(s);
-    toml::value v6(a);
-    toml::value v7(t);
-
-    toml::Boolean  u1 = toml::get<toml::Boolean >(v1);
-    toml::Integer  u2 = toml::get<toml::Integer >(v2);
-    toml::Float    u3 = toml::get<toml::Float   >(v3);
-    toml::String   u4 = toml::get<toml::String  >(v4);
-    toml::Array    u6 = toml::get<toml::Array   >(v6);
-    toml::Table    u7 = toml::get<toml::Table   >(v7);
-
-    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<toml::value_t::Integer>(), a.at(0).cast<toml::value_t::Integer>());
-    BOOST_CHECK_EQUAL(u6.at(1).cast<toml::value_t::Integer>(), a.at(1).cast<toml::value_t::Integer>());
-    BOOST_CHECK_EQUAL(u6.at(2).cast<toml::value_t::Integer>(), a.at(2).cast<toml::value_t::Integer>());
-    BOOST_CHECK_EQUAL(u6.at(3).cast<toml::value_t::Integer>(), a.at(3).cast<toml::value_t::Integer>());
-    BOOST_CHECK_EQUAL(u6.at(4).cast<toml::value_t::Integer>(), a.at(4).cast<toml::value_t::Integer>());
-    BOOST_CHECK_EQUAL(u7.at("val1").cast<toml::value_t::Boolean>(), true);
-    BOOST_CHECK_EQUAL(u7.at("val2").cast<toml::value_t::Integer>(), 42);
-    BOOST_CHECK_CLOSE_FRACTION(u7.at("val3").cast<toml::value_t::Float>(),3.14, 1e-3);
-    BOOST_CHECK_EQUAL(u7.at("val4").cast<toml::value_t::String>(),  "piyo");
-}
-
-
-BOOST_AUTO_TEST_CASE(test_get_cast)
     {
-    toml::Integer  i(42);
+        toml::value v(true);
-    toml::Float    f(3.14);
+        BOOST_CHECK_EQUAL(true, toml::get<toml::boolean>(v));
-    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::get<toml::boolean>(v) = false;
-    toml::value v3(f);
+        BOOST_CHECK_EQUAL(false, toml::get<toml::boolean>(v));
-    toml::value v4(s);
+    }
-    toml::value v5(d);
+    {
-    toml::value v6(a);
+        toml::value v(42);
-    toml::value v7(t);
+        BOOST_CHECK_EQUAL(toml::integer(42), toml::get<toml::integer>(v));
-
+
-    const auto u2 = toml::get<std::size_t>(v2);
+        toml::get<toml::integer>(v) = 54;
-    const auto u3 = toml::get<float>(v3);
+        BOOST_CHECK_EQUAL(toml::integer(54), toml::get<toml::integer>(v));
-    const auto u4 = toml::get<std::deque<int>>(v6);
+    }
-    const auto u5 = toml::get<std::list<int> >(v6);
+    {
-    const auto u6 = toml::get<std::array<int,5>>(v6);
+        toml::value v(3.14);
-    std::map<std::string, toml::value> u7 = toml::get<std::map<std::string, toml::value>>(v7);
+        BOOST_CHECK_EQUAL(toml::floating(3.14), toml::get<toml::floating>(v));
-
+
-    std::deque<int> r4{2,7,1,8,2};
+        toml::get<toml::floating>(v) = 2.71;
-    std::list<int>  r5{2,7,1,8,2};
+        BOOST_CHECK_EQUAL(toml::floating(2.71), toml::get<toml::floating>(v));
-    std::array<int, 5> r6{{2,7,1,8,2}};
+    }
-
+    {
-    BOOST_CHECK_EQUAL(u2, 42ul);
+        toml::value v("foo");
-    BOOST_CHECK_CLOSE_FRACTION(u3, 3.14, 1e-3);
+        BOOST_CHECK_EQUAL(toml::string("foo", toml::string_t::basic),
-    const bool dq = r4 == u4;
+                          toml::get<toml::string>(v));
-    const bool ls = r5 == u5;
+
-    const bool ar = r6 == u6;
+        toml::get<toml::string>(v).str += "bar";
-    BOOST_CHECK(dq);
+        BOOST_CHECK_EQUAL(toml::string("foobar", toml::string_t::basic),
-    BOOST_CHECK(ls);
+                          toml::get<toml::string>(v));
-    BOOST_CHECK(ar);
+    }
-    BOOST_CHECK_EQUAL(u7.at("val1").cast<toml::value_t::Boolean>(), true);
+    {
-    BOOST_CHECK_EQUAL(u7.at("val2").cast<toml::value_t::Integer>(), 42);
+        toml::value v("foo", toml::string_t::literal);
-    BOOST_CHECK_CLOSE_FRACTION(u7.at("val3").cast<toml::value_t::Float>(),3.14, 1e-3);
+        BOOST_CHECK_EQUAL(toml::string("foo", toml::string_t::literal),
-    BOOST_CHECK_EQUAL(u7.at("val4").cast<toml::value_t::String>(),  "piyo");
+                          toml::get<toml::string>(v));
+
+        toml::get<toml::string>(v).str += "bar";
+        BOOST_CHECK_EQUAL(toml::string("foobar", toml::string_t::literal),
+                          toml::get<toml::string>(v));
+    }
+    {
+        toml::local_date d(2018, toml::month_t::Apr, 22);
+        toml::value v(d);
+        BOOST_CHECK(d == toml::get<toml::local_date>(v));
+
+        toml::get<toml::local_date>(v).year = 2017;
+        d.year = 2017;
+        BOOST_CHECK(d == toml::get<toml::local_date>(v));
+    }
+    {
+        toml::local_time t(12, 30, 45);
+        toml::value v(t);
+        BOOST_CHECK(t == toml::get<toml::local_time>(v));
+
+        toml::get<toml::local_time>(v).hour = 9;
+        t.hour = 9;
+        BOOST_CHECK(t == toml::get<toml::local_time>(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<toml::local_datetime>(v));
+
+        toml::get<toml::local_datetime>(v).date.year = 2017;
+        dt.date.year = 2017;
+        BOOST_CHECK(dt == toml::get<toml::local_datetime>(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<toml::offset_datetime>(v));
+
+        toml::get<toml::offset_datetime>(v).date.year = 2017;
+        dt.date.year = 2017;
+        BOOST_CHECK(dt == toml::get<toml::offset_datetime>(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<toml::array>(v));
+
+        toml::get<toml::array>(v).push_back(toml::value(123));
+        vec.push_back(toml::value(123));
+        BOOST_CHECK(vec == toml::get<toml::array>(v));
+    }
+    {
+        toml::table tab;
+        tab["key1"] = toml::value(42);
+        tab["key2"] = toml::value(3.14);
+        toml::value v(tab);
+        BOOST_CHECK(tab == toml::get<toml::table>(v));
+
+        toml::get<toml::table>(v)["key3"] = toml::value(123);
+        tab["key3"] = toml::value(123);
+        BOOST_CHECK(tab == toml::get<toml::table>(v));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_get_integer_type)
+{
+    {
+        toml::value v(42);
+        BOOST_CHECK_EQUAL(int(42),           toml::get<int          >(v));
+        BOOST_CHECK_EQUAL(short(42),         toml::get<short        >(v));
+        BOOST_CHECK_EQUAL(char(42),          toml::get<char         >(v));
+        BOOST_CHECK_EQUAL(unsigned(42),      toml::get<unsigned     >(v));
+        BOOST_CHECK_EQUAL(long(42),          toml::get<long         >(v));
+        BOOST_CHECK_EQUAL(std::int64_t(42),  toml::get<std::int64_t >(v));
+        BOOST_CHECK_EQUAL(std::uint64_t(42), toml::get<std::uint64_t>(v));
+        BOOST_CHECK_EQUAL(std::int16_t(42),  toml::get<std::int16_t >(v));
+        BOOST_CHECK_EQUAL(std::uint16_t(42), toml::get<std::uint16_t>(v));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_get_floating_type)
+{
+    {
+        toml::value v(3.14);
+        BOOST_CHECK_EQUAL(static_cast<float      >(3.14), toml::get<float      >(v));
+        BOOST_CHECK_EQUAL(static_cast<double     >(3.14), toml::get<double     >(v));
+        BOOST_CHECK_EQUAL(static_cast<long double>(3.14), toml::get<long double>(v));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_get_string_type)
+{
+    {
+        toml::value v("foo", toml::string_t::basic);
+        BOOST_CHECK_EQUAL("foo", toml::get<std::string>(v));
+        toml::get<std::string>(v) += "bar";
+        BOOST_CHECK_EQUAL("foobar", toml::get<std::string>(v));
+    }
+    {
+        toml::value v("foo", toml::string_t::literal);
+        BOOST_CHECK_EQUAL("foo", toml::get<std::string>(v));
+        toml::get<std::string>(v) += "bar";
+        BOOST_CHECK_EQUAL("foobar", toml::get<std::string>(v));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_get_toml_array)
+{
+    toml::value v(toml::array(0));
+    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::list<short>         lst = toml::get<std::list<short>>(v);
+    const std::deque<std::int64_t> deq = toml::get<std::deque<std::int64_t>>(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<short>::const_iterator iter = lst.begin();
+    BOOST_CHECK_EQUAL(static_cast<short>(42), *(iter++));
+    BOOST_CHECK_EQUAL(static_cast<short>(54), *(iter++));
+    BOOST_CHECK_EQUAL(static_cast<short>(69), *(iter++));
+    BOOST_CHECK_EQUAL(static_cast<short>(72), *(iter++));
+
+    BOOST_CHECK_EQUAL(static_cast<std::int64_t>(42), deq.at(0));
+    BOOST_CHECK_EQUAL(static_cast<std::int64_t>(54), deq.at(1));
+    BOOST_CHECK_EQUAL(static_cast<std::int64_t>(69), deq.at(2));
+    BOOST_CHECK_EQUAL(static_cast<std::int64_t>(72), deq.at(3));
+
+    std::array<int, 4> ary = toml::get<std::array<int, 4>>(v);
+    BOOST_CHECK_EQUAL(static_cast<int>(42), ary.at(0));
+    BOOST_CHECK_EQUAL(static_cast<int>(54), ary.at(1));
+    BOOST_CHECK_EQUAL(static_cast<int>(69), ary.at(2));
+    BOOST_CHECK_EQUAL(static_cast<int>(72), ary.at(3));
+
+    std::tuple<int, short, unsigned, long> tpl =
+        toml::get<std::tuple<int, short, unsigned, long>>(v);
+    BOOST_CHECK_EQUAL(static_cast<int     >(42), std::get<0>(tpl));
+    BOOST_CHECK_EQUAL(static_cast<short   >(54), std::get<1>(tpl));
+    BOOST_CHECK_EQUAL(static_cast<unsigned>(69), std::get<2>(tpl));
+    BOOST_CHECK_EQUAL(static_cast<long    >(72), std::get<3>(tpl));
+
+    toml::value p(toml::array{});
+    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);
+    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<toml::array>(v1).push_back(toml::value(42));
+    toml::get<toml::array>(v1).push_back(toml::value(54));
+    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 =
+        toml::get<std::pair<std::vector<int>, std::vector<std::string>>>(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<int>, std::vector<std::string>> t =
+        toml::get<std::tuple<std::vector<int>, std::vector<std::string>>>(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");
 }