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

test: add basic_value type to serialization tests

Browse Source
This commit is contained in:
ToruNiina
2019-06-21 15:22:46 +09:00
parent dd9b04ae3b
commit 90918b6d76
7 changed files with 1040 additions and 930 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
tests/test_lex_aux.hpp
View File

@@ -10,17 +10,17 @@ do { \
const std::string expected(expct); \ const std::string expected(expct); \
toml::detail::location<std::string> loc("test", token); \ toml::detail::location<std::string> loc("test", token); \
const auto result = lxr::invoke(loc); \ const auto result = lxr::invoke(loc); \
BOOST_CHECK(result.is_ok()); \ BOOST_TEST(result.is_ok()); \
if(result.is_ok()){ \ if(result.is_ok()){ \
const auto region = result.unwrap(); \ const auto region = result.unwrap(); \
BOOST_CHECK_EQUAL(region.str(), expected); \ BOOST_TEST(region.str() == expected); \
BOOST_CHECK_EQUAL(region.str().size(), expected.size()); \ BOOST_TEST(region.str().size() == expected.size()); \
BOOST_CHECK_EQUAL(static_cast<std::size_t>(std::distance( \ BOOST_TEST(static_cast<std::size_t>(std::distance( \
loc.begin(), loc.iter())), region.size()); \ loc.begin(), loc.iter())) == region.size()); \
} else { \ } else { \
std::cerr << "lexer failed with input `"; \ std::cerr << "lexer failed with input `"; \
std::cerr << token << "`. expected `" << expected << "`\n"; \ std::cerr << token << "`. expected `" << expected << "`\n"; \
std::cerr << "reason: " << result.unwrap_err() << '\n'; \ std::cerr << "reason: " << result.unwrap_err() << '\n'; \
} \ } \
} while(false); \ } while(false); \
/**/ /**/
@@ -30,6 +30,7 @@ do { \
const std::string token (tkn); \ const std::string token (tkn); \
toml::detail::location<std::string> loc("test", token); \ toml::detail::location<std::string> loc("test", token); \
const auto result = lxr::invoke(loc); \ const auto result = lxr::invoke(loc); \
BOOST_CHECK(result.is_err()); \ BOOST_TEST(result.is_err()); \
BOOST_CHECK(loc.begin() == loc.iter()); \ const bool loc_same = (loc.begin() == loc.iter()); \
BOOST_TEST(loc_same); \
} while(false); /**/ } while(false); /**/

117
tests/test_literals.cpp
View File

@@ -19,7 +19,7 @@ BOOST_AUTO_TEST_CASE(test_file_as_literal)
b = "baz" b = "baz"
)"_toml; )"_toml;
BOOST_CHECK_EQUAL(r, v); BOOST_TEST(r == v);
} }
{ {
const toml::value r{ const toml::value r{
@@ -33,7 +33,7 @@ BOOST_AUTO_TEST_CASE(test_file_as_literal)
b = "baz" b = "baz"
)"_toml; )"_toml;
BOOST_CHECK_EQUAL(r, v); BOOST_TEST(r == v);
} }
{ {
const toml::value r{ const toml::value r{
@@ -45,7 +45,7 @@ BOOST_AUTO_TEST_CASE(test_file_as_literal)
b = "baz" b = "baz"
)"_toml; )"_toml;
BOOST_CHECK_EQUAL(r, v); BOOST_TEST(r == v);
} }
} }
@@ -57,31 +57,31 @@ BOOST_AUTO_TEST_CASE(test_value_as_literal)
const toml::value v1 = u8"true"_toml; const toml::value v1 = u8"true"_toml;
const toml::value v2 = u8"false"_toml; const toml::value v2 = u8"false"_toml;
BOOST_CHECK(v1.is_boolean()); BOOST_TEST(v1.is_boolean());
BOOST_CHECK(v2.is_boolean()); BOOST_TEST(v2.is_boolean());
BOOST_CHECK(toml::get<bool>(v1)); BOOST_TEST(toml::get<bool>(v1));
BOOST_CHECK(!toml::get<bool>(v2)); BOOST_TEST(!toml::get<bool>(v2));
} }
{ {
const toml::value v1 = u8"123_456"_toml; const toml::value v1 = u8"123_456"_toml;
const toml::value v2 = u8"0b0010"_toml; const toml::value v2 = u8"0b0010"_toml;
const toml::value v3 = u8"0xDEADBEEF"_toml; const toml::value v3 = u8"0xDEADBEEF"_toml;
BOOST_CHECK(v1.is_integer()); BOOST_TEST(v1.is_integer());
BOOST_CHECK(v2.is_integer()); BOOST_TEST(v2.is_integer());
BOOST_CHECK(v3.is_integer()); BOOST_TEST(v3.is_integer());
BOOST_CHECK_EQUAL(toml::get<toml::integer>(v1), 123456); BOOST_TEST(toml::get<toml::integer>(v1) == 123456);
BOOST_CHECK_EQUAL(toml::get<toml::integer>(v2), 2); BOOST_TEST(toml::get<toml::integer>(v2) == 2);
BOOST_CHECK_EQUAL(toml::get<toml::integer>(v3), 0xDEADBEEF); BOOST_TEST(toml::get<toml::integer>(v3) == 0xDEADBEEF);
} }
{ {
const toml::value v1 = u8"3.1415"_toml; const toml::value v1 = u8"3.1415"_toml;
const toml::value v2 = u8"6.02e+23"_toml; const toml::value v2 = u8"6.02e+23"_toml;
BOOST_CHECK(v1.is_floating()); BOOST_TEST(v1.is_floating());
BOOST_CHECK(v2.is_floating()); BOOST_TEST(v2.is_floating());
BOOST_CHECK_CLOSE(toml::get<double>(v1), 3.1415, 0.00001); BOOST_TEST(toml::get<double>(v1) == 3.1415, boost::test_tools::tolerance(0.00001));
BOOST_CHECK_CLOSE(toml::get<double>(v2), 6.02e23, 0.0001); BOOST_TEST(toml::get<double>(v2) == 6.02e23, boost::test_tools::tolerance(0.0001));
} }
{ {
const toml::value v1 = u8R"("foo")"_toml; const toml::value v1 = u8R"("foo")"_toml;
@@ -89,65 +89,74 @@ BOOST_AUTO_TEST_CASE(test_value_as_literal)
const toml::value v3 = u8R"("""foo""")"_toml; const toml::value v3 = u8R"("""foo""")"_toml;
const toml::value v4 = u8R"('''foo''')"_toml; const toml::value v4 = u8R"('''foo''')"_toml;
BOOST_CHECK(v1.is_string()); BOOST_TEST(v1.is_string());
BOOST_CHECK(v2.is_string()); BOOST_TEST(v2.is_string());
BOOST_CHECK(v3.is_string()); BOOST_TEST(v3.is_string());
BOOST_CHECK(v4.is_string()); BOOST_TEST(v4.is_string());
BOOST_CHECK_EQUAL(toml::get<std::string>(v1), "foo"); BOOST_TEST(toml::get<std::string>(v1) == "foo");
BOOST_CHECK_EQUAL(toml::get<std::string>(v2), "foo"); BOOST_TEST(toml::get<std::string>(v2) == "foo");
BOOST_CHECK_EQUAL(toml::get<std::string>(v3), "foo"); BOOST_TEST(toml::get<std::string>(v3) == "foo");
BOOST_CHECK_EQUAL(toml::get<std::string>(v4), "foo"); BOOST_TEST(toml::get<std::string>(v4) == "foo");
} }
{ {
const toml::value v1 = u8R"([1,2,3])"_toml; {
const toml::value v1 = u8R"([1,2,3])"_toml;
BOOST_CHECK(v1.is_array()); BOOST_TEST(v1.is_array());
BOOST_CHECK((toml::get<std::vector<int>>(v1) == std::vector<int>{1,2,3})); const bool result = (toml::get<std::vector<int>>(v1) == std::vector<int>{1,2,3});
BOOST_TEST(result);
const toml::value v2 = u8R"([1,])"_toml; }
{
BOOST_CHECK(v2.is_array()); const toml::value v2 = u8R"([1,])"_toml;
BOOST_CHECK((toml::get<std::vector<int>>(v2) == std::vector<int>{1})); BOOST_TEST(v2.is_array());
const bool result = (toml::get<std::vector<int>>(v2) == std::vector<int>{1});
const toml::value v3 = u8R"([[1,]])"_toml; BOOST_TEST(result);
BOOST_CHECK(v3.is_array()); }
BOOST_CHECK((toml::get<std::vector<int>>(toml::get<toml::array>(v3).front()) == std::vector<int>{1})); {
const toml::value v3 = u8R"([[1,]])"_toml;
const toml::value v4 = u8R"([[1],])"_toml; BOOST_TEST(v3.is_array());
BOOST_CHECK(v4.is_array()); const bool result = (toml::get<std::vector<int>>(toml::get<toml::array>(v3).front()) == std::vector<int>{1});
BOOST_CHECK((toml::get<std::vector<int>>(toml::get<toml::array>(v4).front()) == std::vector<int>{1})); BOOST_TEST(result);
}
{
const toml::value v4 = u8R"([[1],])"_toml;
BOOST_TEST(v4.is_array());
const bool result = (toml::get<std::vector<int>>(toml::get<toml::array>(v4).front()) == std::vector<int>{1});
BOOST_TEST(result);
}
} }
{ {
const toml::value v1 = u8R"({a = 42})"_toml; const toml::value v1 = u8R"({a = 42})"_toml;
BOOST_CHECK(v1.is_table()); BOOST_TEST(v1.is_table());
BOOST_CHECK((toml::get<std::map<std::string,int>>(v1) == const bool result = toml::get<std::map<std::string,int>>(v1) ==
std::map<std::string,int>{{"a", 42}})); std::map<std::string,int>{{"a", 42}};
BOOST_TEST(result);
} }
{ {
const toml::value v1 = u8"1979-05-27"_toml; const toml::value v1 = u8"1979-05-27"_toml;
BOOST_CHECK(v1.is_local_date()); BOOST_TEST(v1.is_local_date());
BOOST_CHECK_EQUAL(toml::get<toml::local_date>(v1), BOOST_TEST(toml::get<toml::local_date>(v1) ==
toml::local_date(1979, toml::month_t::May, 27)); toml::local_date(1979, toml::month_t::May, 27));
} }
{ {
const toml::value v1 = u8"12:00:00"_toml; const toml::value v1 = u8"12:00:00"_toml;
BOOST_CHECK(v1.is_local_time()); BOOST_TEST(v1.is_local_time());
BOOST_CHECK(toml::get<std::chrono::hours>(v1) == std::chrono::hours(12)); const bool result = toml::get<std::chrono::hours>(v1) == std::chrono::hours(12);
BOOST_TEST(result);
} }
{ {
const toml::value v1 = u8"1979-05-27T07:32:00"_toml; const toml::value v1 = u8"1979-05-27T07:32:00"_toml;
BOOST_CHECK(v1.is_local_datetime()); BOOST_TEST(v1.is_local_datetime());
BOOST_CHECK_EQUAL(toml::get<toml::local_datetime>(v1), BOOST_TEST(toml::get<toml::local_datetime>(v1) ==
toml::local_datetime(toml::local_date(1979, toml::month_t::May, 27), toml::local_datetime(toml::local_date(1979, toml::month_t::May, 27),
toml::local_time(7, 32, 0))); toml::local_time(7, 32, 0)));
} }
{ {
const toml::value v1 = "1979-05-27T07:32:00Z"_toml; const toml::value v1 = "1979-05-27T07:32:00Z"_toml;
BOOST_CHECK(v1.is_offset_datetime()); BOOST_TEST(v1.is_offset_datetime());
BOOST_CHECK_EQUAL(toml::get<toml::offset_datetime>(v1), BOOST_TEST(toml::get<toml::offset_datetime>(v1) ==
toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27), toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27),
toml::local_time(7, 32, 0), toml::time_offset(0, 0))); toml::local_time(7, 32, 0), toml::time_offset(0, 0)));
} }

23
tests/test_parse_aux.hpp
View File

@@ -1,8 +1,7 @@
#include <iostream> #include <iostream>
#include <iomanip> #include <iomanip>
#include <algorithm> #include <algorithm>
#include <toml/region.hpp> #include <toml.hpp>
#include <toml/result.hpp>
// some of the parsers returns not only a value but also a region. // some of the parsers returns not only a value but also a region.
#define TOML11_TEST_PARSE_EQUAL(psr, tkn, expct) \ #define TOML11_TEST_PARSE_EQUAL(psr, tkn, expct) \
@@ -10,13 +9,13 @@ do { \
const std::string token(tkn); \ const std::string token(tkn); \
toml::detail::location<std::string> loc("test", token); \ toml::detail::location<std::string> loc("test", token); \
const auto result = psr(loc); \ const auto result = psr(loc); \
BOOST_CHECK(result.is_ok()); \ BOOST_TEST(result.is_ok()); \
if(result.is_ok()){ \ if(result.is_ok()){ \
BOOST_CHECK(result.unwrap().first == expct); \ BOOST_TEST(result.unwrap().first == expct); \
} else { \ } else { \
std::cerr << "parser " << #psr << " failed with input `"; \ std::cerr << "parser " << #psr << " failed with input `"; \
std::cerr << token << "`.\n"; \ std::cerr << token << "`.\n"; \
std::cerr << "reason: " << result.unwrap_err() << '\n'; \ std::cerr << "reason: " << result.unwrap_err() << '\n'; \
} \ } \
} while(false); \ } while(false); \
/**/ /**/
@@ -26,13 +25,13 @@ do { \
const std::string token(tkn); \ const std::string token(tkn); \
toml::detail::location<std::string> loc("test", token); \ toml::detail::location<std::string> loc("test", token); \
const auto result = psr(loc); \ const auto result = psr(loc); \
BOOST_CHECK(result.is_ok()); \ BOOST_TEST(result.is_ok()); \
if(result.is_ok()){ \ if(result.is_ok()){ \
BOOST_CHECK(result.unwrap() == expct); \ BOOST_TEST(result.unwrap() == expct); \
} else { \ } else { \
std::cerr << "parse_value failed with input `"; \ std::cerr << "parse_value failed with input `"; \
std::cerr << token << "`.\n"; \ std::cerr << token << "`.\n"; \
std::cerr << "reason: " << result.unwrap_err() << '\n'; \ std::cerr << "reason: " << result.unwrap_err() << '\n'; \
} \ } \
} while(false); \ } while(false); \
/**/ /**/

360
tests/test_parse_file.cpp
View File

@@ -15,67 +15,66 @@ BOOST_AUTO_TEST_CASE(test_example)
{ {
const auto data = toml::parse("toml/tests/example.toml"); const auto data = toml::parse("toml/tests/example.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "title"), "TOML Example"); BOOST_TEST(toml::find<std::string>(data, "title") == "TOML Example");
const auto& owner = toml::find(data, "owner"); const auto& owner = toml::find(data, "owner");
{ {
BOOST_CHECK_EQUAL(toml::find<std::string>(owner, "name"), "Tom Preston-Werner"); BOOST_TEST(toml::find<std::string>(owner, "name") == "Tom Preston-Werner");
BOOST_CHECK_EQUAL(toml::find<std::string>(owner, "organization"), "GitHub"); BOOST_TEST(toml::find<std::string>(owner, "organization") == "GitHub");
BOOST_CHECK_EQUAL(toml::find<std::string>(owner, "bio"), BOOST_TEST(toml::find<std::string>(owner, "bio") ==
"GitHub Cofounder & CEO\nLikes tater tots and beer."); "GitHub Cofounder & CEO\nLikes tater tots and beer.");
BOOST_CHECK_EQUAL(toml::find<toml::offset_datetime>(owner, "dob"), BOOST_TEST(toml::find<toml::offset_datetime>(owner, "dob") ==
toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27), toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27),
toml::local_time(7, 32, 0), toml::time_offset(0, 0))); toml::local_time(7, 32, 0), toml::time_offset(0, 0)));
} }
const auto& database = toml::find(data, "database"); const auto& database = toml::find(data, "database");
{ {
BOOST_CHECK_EQUAL(toml::find<std::string>(database, "server"), "192.168.1.1"); BOOST_TEST(toml::find<std::string>(database, "server") == "192.168.1.1");
const std::vector<int> expected_ports{8001, 8001, 8002}; const std::vector<int> expected_ports{8001, 8001, 8002};
BOOST_CHECK(toml::find<std::vector<int>>(database, "ports") == expected_ports); const bool result = toml::find<std::vector<int>>(database, "ports") == expected_ports;
BOOST_CHECK_EQUAL(toml::find<int >(database, "connection_max"), 5000); BOOST_TEST(result);
BOOST_CHECK_EQUAL(toml::find<bool>(database, "enabled"), true); BOOST_TEST(toml::find<int >(database, "connection_max") == 5000);
BOOST_TEST(toml::find<bool>(database, "enabled") == true);
} }
const auto& servers = toml::find(data, "servers"); const auto& servers = toml::find(data, "servers");
{ {
toml::table alpha = toml::find<toml::table>(servers, "alpha"); toml::table alpha = toml::find<toml::table>(servers, "alpha");
BOOST_CHECK_EQUAL(toml::get<std::string>(alpha.at("ip")), "10.0.0.1"); BOOST_TEST(toml::get<std::string>(alpha.at("ip")) == "10.0.0.1");
BOOST_CHECK_EQUAL(toml::get<std::string>(alpha.at("dc")), "eqdc10"); BOOST_TEST(toml::get<std::string>(alpha.at("dc")) == "eqdc10");
toml::table beta = toml::find<toml::table>(servers, "beta"); toml::table beta = toml::find<toml::table>(servers, "beta");
BOOST_CHECK_EQUAL(toml::get<std::string>(beta.at("ip")), "10.0.0.2"); BOOST_TEST(toml::get<std::string>(beta.at("ip")) == "10.0.0.2");
BOOST_CHECK_EQUAL(toml::get<std::string>(beta.at("dc")), "eqdc10"); BOOST_TEST(toml::get<std::string>(beta.at("dc")) == "eqdc10");
BOOST_CHECK_EQUAL(toml::get<std::string>(beta.at("country")), "\xE4\xB8\xAD\xE5\x9B\xBD"); BOOST_TEST(toml::get<std::string>(beta.at("country")) == "\xE4\xB8\xAD\xE5\x9B\xBD");
} }
const auto& clients = toml::find(data, "clients"); const auto& clients = toml::find(data, "clients");
{ {
toml::array clients_data = toml::find<toml::array>(clients, "data"); toml::array clients_data = toml::find<toml::array>(clients, "data");
std::vector<std::string> expected_name{"gamma", "delta"}; std::vector<std::string> expected_name{"gamma", "delta"};
BOOST_CHECK(toml::get<std::vector<std::string>>(clients_data.at(0)) == const bool result1 = toml::get<std::vector<std::string>>(clients_data.at(0)) == expected_name;
expected_name); BOOST_TEST(reuslt1);
std::vector<int> expected_number{1, 2}; std::vector<int> expected_number{1, 2};
BOOST_CHECK(toml::get<std::vector<int>>(clients_data.at(1)) == const bool result2 = toml::get<std::vector<int>>(clients_data.at(1)) == expected_number;
expected_number); BOOST_TEST(reuslt2);
std::vector<std::string> expected_hosts{"alpha", "omega"}; std::vector<std::string> expected_hosts{"alpha", "omega"};
BOOST_CHECK(toml::find<std::vector<std::string>>(clients, "hosts") == const bool result3 = toml::find<std::vector<std::string>>(clients, "hosts") == expected_hosts;
expected_hosts); BOOST_TEST(reuslt3);
} }
std::vector<toml::table> products = std::vector<toml::table> products =
toml::find<std::vector<toml::table>>(data, "products"); toml::find<std::vector<toml::table>>(data, "products");
{ {
BOOST_CHECK_EQUAL(toml::get<std::string>(products.at(0).at("name")), BOOST_TEST(toml::get<std::string>(products.at(0).at("name")) == "Hammer");
"Hammer"); BOOST_TEST(toml::get<std::int64_t>(products.at(0).at("sku")) == 738594937);
BOOST_CHECK_EQUAL(toml::get<std::int64_t>(products.at(0).at("sku")),
738594937);
BOOST_CHECK_EQUAL(toml::get<std::string>(products.at(1).at("name")), BOOST_TEST(toml::get<std::string>(products.at(1).at("name")) == "Nail");
"Nail"); BOOST_TEST(toml::get<std::int64_t>(products.at(1).at("sku")) == 284758393);
BOOST_CHECK_EQUAL(toml::get<std::int64_t>(products.at(1).at("sku")), BOOST_TEST(toml::get<std::string>(products.at(1).at("color")) == "gray");
284758393);
BOOST_CHECK_EQUAL(toml::get<std::string>(products.at(1).at("color")),
"gray");
} }
} }
@@ -84,66 +83,69 @@ BOOST_AUTO_TEST_CASE(test_example_stream)
std::ifstream ifs("toml/tests/example.toml"); std::ifstream ifs("toml/tests/example.toml");
const auto data = toml::parse(ifs); const auto data = toml::parse(ifs);
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "title"), "TOML Example"); BOOST_TEST(toml::find<std::string>(data, "title") == "TOML Example");
const auto& owner = toml::find(data, "owner"); const auto& owner = toml::find(data, "owner");
{ {
BOOST_CHECK_EQUAL(toml::find<std::string>(owner, "name"), "Tom Preston-Werner"); BOOST_TEST(toml::find<std::string>(owner, "name") == "Tom Preston-Werner");
BOOST_CHECK_EQUAL(toml::find<std::string>(owner, "organization"), "GitHub"); BOOST_TEST(toml::find<std::string>(owner, "organization") == "GitHub");
BOOST_CHECK_EQUAL(toml::find<std::string>(owner, "bio"), BOOST_TEST(toml::find<std::string>(owner, "bio") ==
"GitHub Cofounder & CEO\nLikes tater tots and beer."); "GitHub Cofounder & CEO\nLikes tater tots and beer.");
BOOST_CHECK_EQUAL(toml::find<toml::offset_datetime>(owner, "dob"), BOOST_TEST(toml::find<toml::offset_datetime>(owner, "dob") ==
toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27), toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27),
toml::local_time(7, 32, 0), toml::time_offset(0, 0))); toml::local_time(7, 32, 0), toml::time_offset(0, 0)));
} }
const auto& database = toml::find(data, "database"); const auto& database = toml::find(data, "database");
{ {
BOOST_CHECK_EQUAL(toml::find<std::string>(database, "server"), "192.168.1.1"); BOOST_TEST(toml::find<std::string>(database, "server") == "192.168.1.1");
const std::vector<int> expected_ports{8001, 8001, 8002}; const std::vector<int> expected_ports{8001, 8001, 8002};
BOOST_CHECK(toml::find<std::vector<int>>(database, "ports") == expected_ports); const bool result = (toml::find<std::vector<int>>(database, "ports") == expected_ports);
BOOST_CHECK_EQUAL(toml::find<int >(database, "connection_max"), 5000); BOOST_TEST(result);
BOOST_CHECK_EQUAL(toml::find<bool>(database, "enabled"), true); BOOST_TEST(toml::find<int >(database, "connection_max") == 5000);
BOOST_TEST(toml::find<bool>(database, "enabled") == true);
} }
const auto& servers = toml::find(data, "servers"); const auto& servers = toml::find(data, "servers");
{ {
toml::table alpha = toml::find<toml::table>(servers, "alpha"); toml::table alpha = toml::find<toml::table>(servers, "alpha");
BOOST_CHECK_EQUAL(toml::get<std::string>(alpha.at("ip")), "10.0.0.1"); BOOST_TEST(toml::get<std::string>(alpha.at("ip")) == "10.0.0.1");
BOOST_CHECK_EQUAL(toml::get<std::string>(alpha.at("dc")), "eqdc10"); BOOST_TEST(toml::get<std::string>(alpha.at("dc")) == "eqdc10");
toml::table beta = toml::find<toml::table>(servers, "beta"); toml::table beta = toml::find<toml::table>(servers, "beta");
BOOST_CHECK_EQUAL(toml::get<std::string>(beta.at("ip")), "10.0.0.2"); BOOST_TEST(toml::get<std::string>(beta.at("ip")) == "10.0.0.2");
BOOST_CHECK_EQUAL(toml::get<std::string>(beta.at("dc")), "eqdc10"); BOOST_TEST(toml::get<std::string>(beta.at("dc")) == "eqdc10");
BOOST_CHECK_EQUAL(toml::get<std::string>(beta.at("country")), "\xE4\xB8\xAD\xE5\x9B\xBD"); BOOST_TEST(toml::get<std::string>(beta.at("country")) == "\xE4\xB8\xAD\xE5\x9B\xBD");
} }
const auto& clients = toml::find(data, "clients"); const auto& clients = toml::find(data, "clients");
{ {
toml::array clients_data = toml::find<toml::array>(clients, "data"); toml::array clients_data = toml::find<toml::array>(clients, "data");
std::vector<std::string> expected_name{"gamma", "delta"}; std::vector<std::string> expected_name{"gamma", "delta"};
BOOST_CHECK(toml::get<std::vector<std::string>>(clients_data.at(0)) == const bool result1 = toml::get<std::vector<std::string>>(clients_data.at(0)) == expected_name;
expected_name); BOOST_TEST(reuslt1);
std::vector<int> expected_number{1, 2}; std::vector<int> expected_number{1, 2};
BOOST_CHECK(toml::get<std::vector<int>>(clients_data.at(1)) == const bool result2 = toml::get<std::vector<int>>(clients_data.at(1)) == expected_number;
expected_number); BOOST_TEST(reuslt2);
std::vector<std::string> expected_hosts{"alpha", "omega"}; std::vector<std::string> expected_hosts{"alpha", "omega"};
BOOST_CHECK(toml::find<std::vector<std::string>>(clients, "hosts") == const bool result3 = toml::find<std::vector<std::string>>(clients, "hosts") == expected_hosts;
expected_hosts); BOOST_TEST(reuslt3);
} }
std::vector<toml::table> products = std::vector<toml::table> products =
toml::find<std::vector<toml::table>>(data, "products"); toml::find<std::vector<toml::table>>(data, "products");
{ {
BOOST_CHECK_EQUAL(toml::get<std::string>(products.at(0).at("name")), BOOST_TEST(toml::get<std::string>(products.at(0).at("name")) ==
"Hammer"); "Hammer");
BOOST_CHECK_EQUAL(toml::get<std::int64_t>(products.at(0).at("sku")), BOOST_TEST(toml::get<std::int64_t>(products.at(0).at("sku")) ==
738594937); 738594937);
BOOST_CHECK_EQUAL(toml::get<std::string>(products.at(1).at("name")), BOOST_TEST(toml::get<std::string>(products.at(1).at("name")) ==
"Nail"); "Nail");
BOOST_CHECK_EQUAL(toml::get<std::int64_t>(products.at(1).at("sku")), BOOST_TEST(toml::get<std::int64_t>(products.at(1).at("sku")) ==
284758393); 284758393);
BOOST_CHECK_EQUAL(toml::get<std::string>(products.at(1).at("color")), BOOST_TEST(toml::get<std::string>(products.at(1).at("color")) ==
"gray"); "gray");
} }
} }
@@ -152,17 +154,17 @@ BOOST_AUTO_TEST_CASE(test_fruit)
{ {
const auto data = toml::parse("toml/tests/fruit.toml"); const auto data = toml::parse("toml/tests/fruit.toml");
const auto blah = toml::find<toml::array>(toml::find(data, "fruit"), "blah"); const auto blah = toml::find<toml::array>(toml::find(data, "fruit"), "blah");
BOOST_CHECK_EQUAL(toml::find<std::string>(blah.at(0), "name"), "apple"); BOOST_TEST(toml::find<std::string>(blah.at(0), "name") == "apple");
BOOST_CHECK_EQUAL(toml::find<std::string>(blah.at(1), "name"), "banana"); BOOST_TEST(toml::find<std::string>(blah.at(1), "name") == "banana");
{ {
const auto physical = toml::find(blah.at(0), "physical"); const auto physical = toml::find(blah.at(0), "physical");
BOOST_CHECK_EQUAL(toml::find<std::string>(physical, "color"), "red"); BOOST_TEST(toml::find<std::string>(physical, "color") == "red");
BOOST_CHECK_EQUAL(toml::find<std::string>(physical, "shape"), "round"); BOOST_TEST(toml::find<std::string>(physical, "shape") == "round");
} }
{ {
const auto physical = toml::find(blah.at(1), "physical"); const auto physical = toml::find(blah.at(1), "physical");
BOOST_CHECK_EQUAL(toml::find<std::string>(physical, "color"), "yellow"); BOOST_TEST(toml::find<std::string>(physical, "color") == "yellow");
BOOST_CHECK_EQUAL(toml::find<std::string>(physical, "shape"), "bent"); BOOST_TEST(toml::find<std::string>(physical, "shape") == "bent");
} }
} }
@@ -170,7 +172,7 @@ BOOST_AUTO_TEST_CASE(test_hard_example)
{ {
const auto data = toml::parse("toml/tests/hard_example.toml"); const auto data = toml::parse("toml/tests/hard_example.toml");
const auto the = toml::find(data, "the"); const auto the = toml::find(data, "the");
BOOST_CHECK_EQUAL(toml::find<std::string>(the, "test_string"), BOOST_TEST(toml::find<std::string>(the, "test_string") ==
"You'll hate me after this - #"); "You'll hate me after this - #");
const auto hard = toml::find(the, "hard"); const auto hard = toml::find(the, "hard");
@@ -181,13 +183,13 @@ BOOST_AUTO_TEST_CASE(test_hard_example)
"Test #11 ]proved that", "Experiment #9 was a success"}; "Test #11 ]proved that", "Experiment #9 was a success"};
BOOST_CHECK(toml::find<std::vector<std::string>>(hard, "test_array2") == BOOST_CHECK(toml::find<std::vector<std::string>>(hard, "test_array2") ==
expected_the_hard_test_array2); expected_the_hard_test_array2);
BOOST_CHECK_EQUAL(toml::find<std::string>(hard, "another_test_string"), BOOST_TEST(toml::find<std::string>(hard, "another_test_string") ==
" Same thing, but with a string #"); " Same thing, but with a string #");
BOOST_CHECK_EQUAL(toml::find<std::string>(hard, "harder_test_string"), BOOST_TEST(toml::find<std::string>(hard, "harder_test_string") ==
" And when \"'s are in the string, along with # \""); " And when \"'s are in the string, along with # \"");
const auto bit = toml::find(hard, "bit#"); const auto bit = toml::find(hard, "bit#");
BOOST_CHECK_EQUAL(toml::find<std::string>(bit, "what?"), BOOST_TEST(toml::find<std::string>(bit, "what?") ==
"You don't think some user won't do that?"); "You don't think some user won't do that?");
const std::vector<std::string> expected_multi_line_array{"]"}; const std::vector<std::string> expected_multi_line_array{"]"};
BOOST_CHECK(toml::find<std::vector<std::string>>(bit, "multi_line_array") == BOOST_CHECK(toml::find<std::vector<std::string>>(bit, "multi_line_array") ==
@@ -197,7 +199,7 @@ BOOST_AUTO_TEST_CASE(test_hard_example_comment)
{ {
const auto data = toml::parse<toml::preserve_comments>("toml/tests/hard_example.toml"); const auto data = toml::parse<toml::preserve_comments>("toml/tests/hard_example.toml");
const auto the = toml::find(data, "the"); const auto the = toml::find(data, "the");
BOOST_CHECK_EQUAL(toml::find<std::string>(the, "test_string"), BOOST_TEST(toml::find<std::string>(the, "test_string") ==
"You'll hate me after this - #"); "You'll hate me after this - #");
const auto hard = toml::find(the, "hard"); const auto hard = toml::find(the, "hard");
@@ -208,13 +210,13 @@ BOOST_AUTO_TEST_CASE(test_hard_example_comment)
"Test #11 ]proved that", "Experiment #9 was a success"}; "Test #11 ]proved that", "Experiment #9 was a success"};
BOOST_CHECK(toml::find<std::vector<std::string>>(hard, "test_array2") == BOOST_CHECK(toml::find<std::vector<std::string>>(hard, "test_array2") ==
expected_the_hard_test_array2); expected_the_hard_test_array2);
BOOST_CHECK_EQUAL(toml::find<std::string>(hard, "another_test_string"), BOOST_TEST(toml::find<std::string>(hard, "another_test_string") ==
" Same thing, but with a string #"); " Same thing, but with a string #");
BOOST_CHECK_EQUAL(toml::find<std::string>(hard, "harder_test_string"), BOOST_TEST(toml::find<std::string>(hard, "harder_test_string") ==
" And when \"'s are in the string, along with # \""); " And when \"'s are in the string, along with # \"");
const auto bit = toml::find(hard, "bit#"); const auto bit = toml::find(hard, "bit#");
BOOST_CHECK_EQUAL(toml::find<std::string>(bit, "what?"), BOOST_TEST(toml::find<std::string>(bit, "what?") ==
"You don't think some user won't do that?"); "You don't think some user won't do that?");
const std::vector<std::string> expected_multi_line_array{"]"}; const std::vector<std::string> expected_multi_line_array{"]"};
BOOST_CHECK(toml::find<std::vector<std::string>>(bit, "multi_line_array") == BOOST_CHECK(toml::find<std::vector<std::string>>(bit, "multi_line_array") ==
@@ -226,49 +228,49 @@ BOOST_AUTO_TEST_CASE(test_example_preserve_comment)
{ {
const auto data = toml::parse<toml::preserve_comments>("toml/tests/example.toml"); const auto data = toml::parse<toml::preserve_comments>("toml/tests/example.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "title"), "TOML Example"); BOOST_TEST(toml::find<std::string>(data, "title") == "TOML Example");
const auto& owner = toml::find(data, "owner"); const auto& owner = toml::find(data, "owner");
{ {
BOOST_CHECK_EQUAL(toml::find<std::string>(owner, "name"), "Tom Preston-Werner"); BOOST_TEST(toml::find<std::string>(owner, "name") == "Tom Preston-Werner");
BOOST_CHECK_EQUAL(toml::find<std::string>(owner, "organization"), "GitHub"); BOOST_TEST(toml::find<std::string>(owner, "organization") == "GitHub");
BOOST_CHECK_EQUAL(toml::find<std::string>(owner, "bio"), BOOST_TEST(toml::find<std::string>(owner, "bio") ==
"GitHub Cofounder & CEO\nLikes tater tots and beer."); "GitHub Cofounder & CEO\nLikes tater tots and beer.");
BOOST_CHECK_EQUAL(toml::find<toml::offset_datetime>(owner, "dob"), BOOST_TEST(toml::find<toml::offset_datetime>(owner, "dob") ==
toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27), toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27),
toml::local_time(7, 32, 0), toml::time_offset(0, 0))); toml::local_time(7, 32, 0), toml::time_offset(0, 0)));
BOOST_CHECK_EQUAL(toml::find(owner, "dob").comments().at(0), BOOST_TEST(toml::find(owner, "dob").comments().at(0) ==
" First class dates? Why not?"); " First class dates? Why not?");
} }
const auto& database = toml::find(data, "database"); const auto& database = toml::find(data, "database");
{ {
BOOST_CHECK_EQUAL(toml::find<std::string>(database, "server"), "192.168.1.1"); BOOST_TEST(toml::find<std::string>(database, "server") == "192.168.1.1");
const std::vector<int> expected_ports{8001, 8001, 8002}; const std::vector<int> expected_ports{8001, 8001, 8002};
BOOST_CHECK(toml::find<std::vector<int>>(database, "ports") == expected_ports); BOOST_CHECK(toml::find<std::vector<int>>(database, "ports") == expected_ports);
BOOST_CHECK_EQUAL(toml::find<int >(database, "connection_max"), 5000); BOOST_TEST(toml::find<int >(database, "connection_max") == 5000);
BOOST_CHECK_EQUAL(toml::find<bool>(database, "enabled"), true); BOOST_TEST(toml::find<bool>(database, "enabled") == true);
} }
const auto& servers = toml::find(data, "servers"); const auto& servers = toml::find(data, "servers");
{ {
const auto& alpha = toml::find(servers, "alpha"); const auto& alpha = toml::find(servers, "alpha");
BOOST_CHECK_EQUAL(alpha.comments().at(0), BOOST_TEST(alpha.comments().at(0) ==
" You can indent as you please. Tabs or spaces. TOML don't care."); " You can indent as you please. Tabs or spaces. TOML don't care.");
BOOST_CHECK_EQUAL(toml::find<std::string>(alpha, "ip"), "10.0.0.1"); BOOST_TEST(toml::find<std::string>(alpha, "ip") == "10.0.0.1");
BOOST_CHECK_EQUAL(toml::find<std::string>(alpha, "dc"), "eqdc10"); BOOST_TEST(toml::find<std::string>(alpha, "dc") == "eqdc10");
const auto& beta = toml::find(servers, "beta"); const auto& beta = toml::find(servers, "beta");
BOOST_CHECK_EQUAL(toml::find<std::string>(beta, "ip"), "10.0.0.2"); BOOST_TEST(toml::find<std::string>(beta, "ip") == "10.0.0.2");
BOOST_CHECK_EQUAL(toml::find<std::string>(beta, "dc"), "eqdc10"); BOOST_TEST(toml::find<std::string>(beta, "dc") == "eqdc10");
BOOST_CHECK_EQUAL(toml::find<std::string>(beta, "country"), BOOST_TEST(toml::find<std::string>(beta, "country") ==
"\xE4\xB8\xAD\xE5\x9B\xBD"); "\xE4\xB8\xAD\xE5\x9B\xBD");
BOOST_CHECK_EQUAL(toml::find(beta, "country").comments().at(0), BOOST_TEST(toml::find(beta, "country").comments().at(0) ==
" This should be parsed as UTF-8"); " This should be parsed as UTF-8");
} }
const auto& clients = toml::find(data, "clients"); const auto& clients = toml::find(data, "clients");
{ {
BOOST_CHECK_EQUAL(toml::find(clients, "data").comments().at(0), BOOST_TEST(toml::find(clients, "data").comments().at(0) ==
" just an update to make sure parsers support it"); " just an update to make sure parsers support it");
@@ -283,23 +285,23 @@ BOOST_AUTO_TEST_CASE(test_example_preserve_comment)
BOOST_CHECK(toml::find<std::vector<std::string>>(clients, "hosts") == BOOST_CHECK(toml::find<std::vector<std::string>>(clients, "hosts") ==
expected_hosts); expected_hosts);
BOOST_CHECK_EQUAL(toml::find(clients, "hosts").comments().at(0), BOOST_TEST(toml::find(clients, "hosts").comments().at(0) ==
" Line breaks are OK when inside arrays"); " Line breaks are OK when inside arrays");
} }
std::vector<toml::table> products = std::vector<toml::table> products =
toml::find<std::vector<toml::table>>(data, "products"); toml::find<std::vector<toml::table>>(data, "products");
{ {
BOOST_CHECK_EQUAL(toml::get<std::string>(products.at(0).at("name")), BOOST_TEST(toml::get<std::string>(products.at(0).at("name")) ==
"Hammer"); "Hammer");
BOOST_CHECK_EQUAL(toml::get<std::int64_t>(products.at(0).at("sku")), BOOST_TEST(toml::get<std::int64_t>(products.at(0).at("sku")) ==
738594937); 738594937);
BOOST_CHECK_EQUAL(toml::get<std::string>(products.at(1).at("name")), BOOST_TEST(toml::get<std::string>(products.at(1).at("name")) ==
"Nail"); "Nail");
BOOST_CHECK_EQUAL(toml::get<std::int64_t>(products.at(1).at("sku")), BOOST_TEST(toml::get<std::int64_t>(products.at(1).at("sku")) ==
284758393); 284758393);
BOOST_CHECK_EQUAL(toml::get<std::string>(products.at(1).at("color")), BOOST_TEST(toml::get<std::string>(products.at(1).at("color")) ==
"gray"); "gray");
} }
} }
@@ -316,49 +318,49 @@ BOOST_AUTO_TEST_CASE(test_example_preserve_stdmap_stddeque)
std::deque<typename std::remove_cv<decltype(data)>::type> std::deque<typename std::remove_cv<decltype(data)>::type>
>::value, ""); >::value, "");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "title"), "TOML Example"); BOOST_TEST(toml::find<std::string>(data, "title") == "TOML Example");
const auto& owner = toml::find(data, "owner"); const auto& owner = toml::find(data, "owner");
{ {
BOOST_CHECK_EQUAL(toml::find<std::string>(owner, "name"), "Tom Preston-Werner"); BOOST_TEST(toml::find<std::string>(owner, "name") == "Tom Preston-Werner");
BOOST_CHECK_EQUAL(toml::find<std::string>(owner, "organization"), "GitHub"); BOOST_TEST(toml::find<std::string>(owner, "organization") == "GitHub");
BOOST_CHECK_EQUAL(toml::find<std::string>(owner, "bio"), BOOST_TEST(toml::find<std::string>(owner, "bio") ==
"GitHub Cofounder & CEO\nLikes tater tots and beer."); "GitHub Cofounder & CEO\nLikes tater tots and beer.");
BOOST_CHECK_EQUAL(toml::find<toml::offset_datetime>(owner, "dob"), BOOST_TEST(toml::find<toml::offset_datetime>(owner, "dob") ==
toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27), toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27),
toml::local_time(7, 32, 0), toml::time_offset(0, 0))); toml::local_time(7, 32, 0), toml::time_offset(0, 0)));
BOOST_CHECK_EQUAL(toml::find(owner, "dob").comments().at(0), BOOST_TEST(toml::find(owner, "dob").comments().at(0) ==
" First class dates? Why not?"); " First class dates? Why not?");
} }
const auto& database = toml::find(data, "database"); const auto& database = toml::find(data, "database");
{ {
BOOST_CHECK_EQUAL(toml::find<std::string>(database, "server"), "192.168.1.1"); BOOST_TEST(toml::find<std::string>(database, "server") == "192.168.1.1");
const std::vector<int> expected_ports{8001, 8001, 8002}; const std::vector<int> expected_ports{8001, 8001, 8002};
BOOST_CHECK(toml::find<std::vector<int>>(database, "ports") == expected_ports); BOOST_CHECK(toml::find<std::vector<int>>(database, "ports") == expected_ports);
BOOST_CHECK_EQUAL(toml::find<int >(database, "connection_max"), 5000); BOOST_TEST(toml::find<int >(database, "connection_max") == 5000);
BOOST_CHECK_EQUAL(toml::find<bool>(database, "enabled"), true); BOOST_TEST(toml::find<bool>(database, "enabled") == true);
} }
const auto& servers = toml::find(data, "servers"); const auto& servers = toml::find(data, "servers");
{ {
const auto& alpha = toml::find(servers, "alpha"); const auto& alpha = toml::find(servers, "alpha");
BOOST_CHECK_EQUAL(alpha.comments().at(0), BOOST_TEST(alpha.comments().at(0) ==
" You can indent as you please. Tabs or spaces. TOML don't care."); " You can indent as you please. Tabs or spaces. TOML don't care.");
BOOST_CHECK_EQUAL(toml::find<std::string>(alpha, "ip"), "10.0.0.1"); BOOST_TEST(toml::find<std::string>(alpha, "ip") == "10.0.0.1");
BOOST_CHECK_EQUAL(toml::find<std::string>(alpha, "dc"), "eqdc10"); BOOST_TEST(toml::find<std::string>(alpha, "dc") == "eqdc10");
const auto& beta = toml::find(servers, "beta"); const auto& beta = toml::find(servers, "beta");
BOOST_CHECK_EQUAL(toml::find<std::string>(beta, "ip"), "10.0.0.2"); BOOST_TEST(toml::find<std::string>(beta, "ip") == "10.0.0.2");
BOOST_CHECK_EQUAL(toml::find<std::string>(beta, "dc"), "eqdc10"); BOOST_TEST(toml::find<std::string>(beta, "dc") == "eqdc10");
BOOST_CHECK_EQUAL(toml::find<std::string>(beta, "country"), BOOST_TEST(toml::find<std::string>(beta, "country") ==
"\xE4\xB8\xAD\xE5\x9B\xBD"); "\xE4\xB8\xAD\xE5\x9B\xBD");
BOOST_CHECK_EQUAL(toml::find(beta, "country").comments().at(0), BOOST_TEST(toml::find(beta, "country").comments().at(0) ==
" This should be parsed as UTF-8"); " This should be parsed as UTF-8");
} }
const auto& clients = toml::find(data, "clients"); const auto& clients = toml::find(data, "clients");
{ {
BOOST_CHECK_EQUAL(toml::find(clients, "data").comments().at(0), BOOST_TEST(toml::find(clients, "data").comments().at(0) ==
" just an update to make sure parsers support it"); " just an update to make sure parsers support it");
@@ -373,23 +375,23 @@ BOOST_AUTO_TEST_CASE(test_example_preserve_stdmap_stddeque)
BOOST_CHECK(toml::find<std::vector<std::string>>(clients, "hosts") == BOOST_CHECK(toml::find<std::vector<std::string>>(clients, "hosts") ==
expected_hosts); expected_hosts);
BOOST_CHECK_EQUAL(toml::find(clients, "hosts").comments().at(0), BOOST_TEST(toml::find(clients, "hosts").comments().at(0) ==
" Line breaks are OK when inside arrays"); " Line breaks are OK when inside arrays");
} }
std::vector<toml::table> products = std::vector<toml::table> products =
toml::find<std::vector<toml::table>>(data, "products"); toml::find<std::vector<toml::table>>(data, "products");
{ {
BOOST_CHECK_EQUAL(toml::get<std::string>(products.at(0).at("name")), BOOST_TEST(toml::get<std::string>(products.at(0).at("name")) ==
"Hammer"); "Hammer");
BOOST_CHECK_EQUAL(toml::get<std::int64_t>(products.at(0).at("sku")), BOOST_TEST(toml::get<std::int64_t>(products.at(0).at("sku")) ==
738594937); 738594937);
BOOST_CHECK_EQUAL(toml::get<std::string>(products.at(1).at("name")), BOOST_TEST(toml::get<std::string>(products.at(1).at("name")) ==
"Nail"); "Nail");
BOOST_CHECK_EQUAL(toml::get<std::int64_t>(products.at(1).at("sku")), BOOST_TEST(toml::get<std::int64_t>(products.at(1).at("sku")) ==
284758393); 284758393);
BOOST_CHECK_EQUAL(toml::get<std::string>(products.at(1).at("color")), BOOST_TEST(toml::get<std::string>(products.at(1).at("color")) ==
"gray"); "gray");
} }
} }
@@ -409,8 +411,8 @@ BOOST_AUTO_TEST_CASE(test_file_with_BOM)
std::istringstream iss(table); std::istringstream iss(table);
const auto data = toml::parse(iss, "test_file_with_BOM.toml"); const auto data = toml::parse(iss, "test_file_with_BOM.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -425,8 +427,8 @@ BOOST_AUTO_TEST_CASE(test_file_with_BOM)
} }
const auto data = toml::parse("tmp.toml"); const auto data = toml::parse("tmp.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -438,8 +440,8 @@ BOOST_AUTO_TEST_CASE(test_file_with_BOM)
std::istringstream iss(table); std::istringstream iss(table);
const auto data = toml::parse(iss, "test_file_with_BOM_CRLF.toml"); const auto data = toml::parse(iss, "test_file_with_BOM_CRLF.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -457,8 +459,8 @@ BOOST_AUTO_TEST_CASE(test_file_with_BOM)
} }
const auto data = toml::parse("tmp.toml"); const auto data = toml::parse("tmp.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
} }
@@ -474,8 +476,8 @@ BOOST_AUTO_TEST_CASE(test_file_without_newline_at_the_end_of_file)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_file_without_newline_at_the_end_of_file.toml"); "test_file_without_newline_at_the_end_of_file.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -487,8 +489,8 @@ BOOST_AUTO_TEST_CASE(test_file_without_newline_at_the_end_of_file)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_file_without_newline_at_the_end_of_file_CRLF.toml"); "test_file_without_newline_at_the_end_of_file_CRLF.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
@@ -501,8 +503,8 @@ BOOST_AUTO_TEST_CASE(test_file_without_newline_at_the_end_of_file)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_file_without_newline_at_the_end_of_file_comment.toml"); "test_file_without_newline_at_the_end_of_file_comment.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -514,8 +516,8 @@ BOOST_AUTO_TEST_CASE(test_file_without_newline_at_the_end_of_file)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_file_without_newline_at_the_end_of_file_comment.toml"); "test_file_without_newline_at_the_end_of_file_comment.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
@@ -528,8 +530,8 @@ BOOST_AUTO_TEST_CASE(test_file_without_newline_at_the_end_of_file)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_file_without_newline_at_the_end_of_file_ws.toml"); "test_file_without_newline_at_the_end_of_file_ws.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -541,8 +543,8 @@ BOOST_AUTO_TEST_CASE(test_file_without_newline_at_the_end_of_file)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_file_without_newline_at_the_end_of_file_ws.toml"); "test_file_without_newline_at_the_end_of_file_ws.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
} }
@@ -561,8 +563,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_comment)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_comment.toml"); "test_files_end_with_comment.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -576,8 +578,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_comment)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_comment.toml"); "test_files_end_with_comment.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
// comment w/ newline // comment w/ newline
@@ -593,8 +595,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_comment)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_comment.toml"); "test_files_end_with_comment.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -608,8 +610,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_comment)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_comment.toml"); "test_files_end_with_comment.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
// CRLF version // CRLF version
@@ -625,8 +627,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_comment)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_comment.toml"); "test_files_end_with_comment.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -640,8 +642,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_comment)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_comment.toml"); "test_files_end_with_comment.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -654,8 +656,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_comment)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_comment.toml"); "test_files_end_with_comment.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -669,8 +671,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_comment)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_comment.toml"); "test_files_end_with_comment.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
} }
@@ -688,8 +690,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_newline.toml"); "test_files_end_with_newline.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -703,8 +705,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_newline.toml"); "test_files_end_with_newline.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
// with whitespaces // with whitespaces
@@ -720,8 +722,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_newline.toml"); "test_files_end_with_newline.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -735,8 +737,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_newline.toml"); "test_files_end_with_newline.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -750,8 +752,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_newline.toml"); "test_files_end_with_newline.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -765,8 +767,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_newline.toml"); "test_files_end_with_newline.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
// with whitespaces but no newline // with whitespaces but no newline
@@ -781,8 +783,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_newline.toml"); "test_files_end_with_newline.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
@@ -799,8 +801,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_newline.toml"); "test_files_end_with_newline.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -814,8 +816,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_newline.toml"); "test_files_end_with_newline.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
// with whitespaces // with whitespaces
@@ -831,8 +833,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_newline.toml"); "test_files_end_with_newline.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -846,8 +848,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_newline.toml"); "test_files_end_with_newline.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -861,8 +863,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_newline.toml"); "test_files_end_with_newline.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -876,8 +878,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_newline.toml"); "test_files_end_with_newline.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
{ {
const std::string table( const std::string table(
@@ -890,8 +892,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
const auto data = toml::parse(iss, const auto data = toml::parse(iss,
"test_files_end_with_newline.toml"); "test_files_end_with_newline.toml");
BOOST_CHECK_EQUAL(toml::find<std::string>(data, "key"), "value"); BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_CHECK_EQUAL(toml::find<std::string>(toml::find(data, "table"), "key"), "value"); BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
} }
} }

256
tests/test_result.cpp
View File

@@ -8,49 +8,49 @@ BOOST_AUTO_TEST_CASE(test_construct)
{ {
auto s = toml::ok(42); auto s = toml::ok(42);
toml::result<int, std::string> result(s); toml::result<int, std::string> result(s);
BOOST_CHECK(!!result); BOOST_TEST(!!result);
BOOST_CHECK(result.is_ok()); BOOST_TEST(result.is_ok());
BOOST_CHECK(!result.is_err()); BOOST_TEST(!result.is_err());
BOOST_CHECK_EQUAL(result.unwrap(), 42); BOOST_TEST(result.unwrap() == 42);
} }
{ {
const auto s = toml::ok(42); const auto s = toml::ok(42);
toml::result<int, std::string> result(s); toml::result<int, std::string> result(s);
BOOST_CHECK(!!result); BOOST_TEST(!!result);
BOOST_CHECK(result.is_ok()); BOOST_TEST(result.is_ok());
BOOST_CHECK(!result.is_err()); BOOST_TEST(!result.is_err());
BOOST_CHECK_EQUAL(result.unwrap(), 42); BOOST_TEST(result.unwrap() == 42);
} }
{ {
toml::result<int, std::string> result(toml::ok(42)); toml::result<int, std::string> result(toml::ok(42));
BOOST_CHECK(!!result); BOOST_TEST(!!result);
BOOST_CHECK(result.is_ok()); BOOST_TEST(result.is_ok());
BOOST_CHECK(!result.is_err()); BOOST_TEST(!result.is_err());
BOOST_CHECK_EQUAL(result.unwrap(), 42); BOOST_TEST(result.unwrap() == 42);
} }
{ {
auto f = toml::err<std::string>("foobar"); auto f = toml::err<std::string>("foobar");
toml::result<int, std::string> result(f); toml::result<int, std::string> result(f);
BOOST_CHECK(!result); BOOST_TEST(!result);
BOOST_CHECK(!result.is_ok()); BOOST_TEST(!result.is_ok());
BOOST_CHECK(result.is_err()); BOOST_TEST(result.is_err());
BOOST_CHECK_EQUAL(result.unwrap_err(), "foobar"); BOOST_TEST(result.unwrap_err() == "foobar");
} }
{ {
const auto f = toml::err<std::string>("foobar"); const auto f = toml::err<std::string>("foobar");
toml::result<int, std::string> result(f); toml::result<int, std::string> result(f);
BOOST_CHECK(!result); BOOST_TEST(!result);
BOOST_CHECK(!result.is_ok()); BOOST_TEST(!result.is_ok());
BOOST_CHECK(result.is_err()); BOOST_TEST(result.is_err());
BOOST_CHECK_EQUAL(result.unwrap_err(), "foobar"); BOOST_TEST(result.unwrap_err() == "foobar");
} }
{ {
toml::result<int, std::string> result(toml::err<std::string>("foobar")); toml::result<int, std::string> result(toml::err<std::string>("foobar"));
BOOST_CHECK(!result); BOOST_TEST(!result);
BOOST_CHECK(!result.is_ok()); BOOST_TEST(!result.is_ok());
BOOST_CHECK(result.is_err()); BOOST_TEST(result.is_err());
BOOST_CHECK_EQUAL(result.unwrap_err(), "foobar"); BOOST_TEST(result.unwrap_err() == "foobar");
} }
} }
@@ -59,54 +59,54 @@ BOOST_AUTO_TEST_CASE(test_assignment)
{ {
toml::result<int, std::string> result(toml::err<std::string>("foobar")); toml::result<int, std::string> result(toml::err<std::string>("foobar"));
result = toml::ok(42); result = toml::ok(42);
BOOST_CHECK(!!result); BOOST_TEST(!!result);
BOOST_CHECK(result.is_ok()); BOOST_TEST(result.is_ok());
BOOST_CHECK(!result.is_err()); BOOST_TEST(!result.is_err());
BOOST_CHECK_EQUAL(result.unwrap(), 42); BOOST_TEST(result.unwrap() == 42);
} }
{ {
toml::result<int, std::string> result(toml::err<std::string>("foobar")); toml::result<int, std::string> result(toml::err<std::string>("foobar"));
auto s = toml::ok(42); auto s = toml::ok(42);
result = s; result = s;
BOOST_CHECK(!!result); BOOST_TEST(!!result);
BOOST_CHECK(result.is_ok()); BOOST_TEST(result.is_ok());
BOOST_CHECK(!result.is_err()); BOOST_TEST(!result.is_err());
BOOST_CHECK_EQUAL(result.unwrap(), 42); BOOST_TEST(result.unwrap() == 42);
} }
{ {
toml::result<int, std::string> result(toml::err<std::string>("foobar")); toml::result<int, std::string> result(toml::err<std::string>("foobar"));
const auto s = toml::ok(42); const auto s = toml::ok(42);
result = s; result = s;
BOOST_CHECK(!!result); BOOST_TEST(!!result);
BOOST_CHECK(result.is_ok()); BOOST_TEST(result.is_ok());
BOOST_CHECK(!result.is_err()); BOOST_TEST(!result.is_err());
BOOST_CHECK_EQUAL(result.unwrap(), 42); BOOST_TEST(result.unwrap() == 42);
} }
{ {
toml::result<int, std::string> result(toml::err<std::string>("foobar")); toml::result<int, std::string> result(toml::err<std::string>("foobar"));
result = toml::err<std::string>("hoge"); result = toml::err<std::string>("hoge");
BOOST_CHECK(!result); BOOST_TEST(!result);
BOOST_CHECK(!result.is_ok()); BOOST_TEST(!result.is_ok());
BOOST_CHECK(result.is_err()); BOOST_TEST(result.is_err());
BOOST_CHECK_EQUAL(result.unwrap_err(), "hoge"); BOOST_TEST(result.unwrap_err() == "hoge");
} }
{ {
toml::result<int, std::string> result(toml::err<std::string>("foobar")); toml::result<int, std::string> result(toml::err<std::string>("foobar"));
auto f = toml::err<std::string>("hoge"); auto f = toml::err<std::string>("hoge");
result = f; result = f;
BOOST_CHECK(!result); BOOST_TEST(!result);
BOOST_CHECK(!result.is_ok()); BOOST_TEST(!result.is_ok());
BOOST_CHECK(result.is_err()); BOOST_TEST(result.is_err());
BOOST_CHECK_EQUAL(result.unwrap_err(), "hoge"); BOOST_TEST(result.unwrap_err() == "hoge");
} }
{ {
toml::result<int, std::string> result(toml::err<std::string>("foobar")); toml::result<int, std::string> result(toml::err<std::string>("foobar"));
const auto f = toml::err<std::string>("hoge"); const auto f = toml::err<std::string>("hoge");
result = f; result = f;
BOOST_CHECK(!result); BOOST_TEST(!result);
BOOST_CHECK(!result.is_ok()); BOOST_TEST(!result.is_ok());
BOOST_CHECK(result.is_err()); BOOST_TEST(result.is_err());
BOOST_CHECK_EQUAL(result.unwrap_err(), "hoge"); BOOST_TEST(result.unwrap_err() == "hoge");
} }
} }
@@ -119,10 +119,10 @@ BOOST_AUTO_TEST_CASE(test_map)
return i * 2; return i * 2;
}); });
BOOST_CHECK(!!mapped); BOOST_TEST(!!mapped);
BOOST_CHECK(mapped.is_ok()); BOOST_TEST(mapped.is_ok());
BOOST_CHECK(!mapped.is_err()); BOOST_TEST(!mapped.is_err());
BOOST_CHECK_EQUAL(mapped.unwrap(), 42 * 2); BOOST_TEST(mapped.unwrap() == 42 * 2);
} }
{ {
toml::result<std::unique_ptr<int>, std::string> toml::result<std::unique_ptr<int>, std::string>
@@ -132,10 +132,10 @@ BOOST_AUTO_TEST_CASE(test_map)
return *i; return *i;
}); });
BOOST_CHECK(!!mapped); BOOST_TEST(!!mapped);
BOOST_CHECK(mapped.is_ok()); BOOST_TEST(mapped.is_ok());
BOOST_CHECK(!mapped.is_err()); BOOST_TEST(!mapped.is_err());
BOOST_CHECK_EQUAL(mapped.unwrap(), 42); BOOST_TEST(mapped.unwrap() == 42);
} }
{ {
const toml::result<int, std::string> result(toml::err<std::string>("hoge")); const toml::result<int, std::string> result(toml::err<std::string>("hoge"));
@@ -144,10 +144,10 @@ BOOST_AUTO_TEST_CASE(test_map)
return i * 2; return i * 2;
}); });
BOOST_CHECK(!mapped); BOOST_TEST(!mapped);
BOOST_CHECK(!mapped.is_ok()); BOOST_TEST(!mapped.is_ok());
BOOST_CHECK(mapped.is_err()); BOOST_TEST(mapped.is_err());
BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hoge"); BOOST_TEST(mapped.unwrap_err() == "hoge");
} }
{ {
toml::result<std::unique_ptr<int>, std::string> toml::result<std::unique_ptr<int>, std::string>
@@ -157,10 +157,10 @@ BOOST_AUTO_TEST_CASE(test_map)
return *i; return *i;
}); });
BOOST_CHECK(!mapped); BOOST_TEST(!mapped);
BOOST_CHECK(!mapped.is_ok()); BOOST_TEST(!mapped.is_ok());
BOOST_CHECK(mapped.is_err()); BOOST_TEST(mapped.is_err());
BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hoge"); BOOST_TEST(mapped.unwrap_err() == "hoge");
} }
} }
@@ -173,10 +173,10 @@ BOOST_AUTO_TEST_CASE(test_map_err)
return s + s; return s + s;
}); });
BOOST_CHECK(!!mapped); BOOST_TEST(!!mapped);
BOOST_CHECK(mapped.is_ok()); BOOST_TEST(mapped.is_ok());
BOOST_CHECK(!mapped.is_err()); BOOST_TEST(!mapped.is_err());
BOOST_CHECK_EQUAL(mapped.unwrap(), 42); BOOST_TEST(mapped.unwrap() == 42);
} }
{ {
toml::result<std::unique_ptr<int>, std::string> toml::result<std::unique_ptr<int>, std::string>
@@ -186,10 +186,10 @@ BOOST_AUTO_TEST_CASE(test_map_err)
return s + s; return s + s;
}); });
BOOST_CHECK(!!mapped); BOOST_TEST(!!mapped);
BOOST_CHECK(mapped.is_ok()); BOOST_TEST(mapped.is_ok());
BOOST_CHECK(!mapped.is_err()); BOOST_TEST(!mapped.is_err());
BOOST_CHECK_EQUAL(*(mapped.unwrap()), 42); BOOST_TEST(*(mapped.unwrap()) == 42);
} }
{ {
const toml::result<int, std::string> result(toml::err<std::string>("hoge")); const toml::result<int, std::string> result(toml::err<std::string>("hoge"));
@@ -197,10 +197,10 @@ BOOST_AUTO_TEST_CASE(test_map_err)
[](const std::string s) -> std::string { [](const std::string s) -> std::string {
return s + s; return s + s;
}); });
BOOST_CHECK(!mapped); BOOST_TEST(!mapped);
BOOST_CHECK(!mapped.is_ok()); BOOST_TEST(!mapped.is_ok());
BOOST_CHECK(mapped.is_err()); BOOST_TEST(mapped.is_err());
BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hogehoge"); BOOST_TEST(mapped.unwrap_err() == "hogehoge");
} }
{ {
toml::result<int, std::unique_ptr<std::string>> toml::result<int, std::unique_ptr<std::string>>
@@ -210,10 +210,10 @@ BOOST_AUTO_TEST_CASE(test_map_err)
return *p; return *p;
}); });
BOOST_CHECK(!mapped); BOOST_TEST(!mapped);
BOOST_CHECK(!mapped.is_ok()); BOOST_TEST(!mapped.is_ok());
BOOST_CHECK(mapped.is_err()); BOOST_TEST(mapped.is_err());
BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hoge"); BOOST_TEST(mapped.unwrap_err() == "hoge");
} }
} }
@@ -226,7 +226,7 @@ BOOST_AUTO_TEST_CASE(test_map_or_else)
return i * 2; return i * 2;
}, 54); }, 54);
BOOST_CHECK_EQUAL(mapped, 42 * 2); BOOST_TEST(mapped == 42 * 2);
} }
{ {
toml::result<std::unique_ptr<int>, std::string> toml::result<std::unique_ptr<int>, std::string>
@@ -236,7 +236,7 @@ BOOST_AUTO_TEST_CASE(test_map_or_else)
return *i; return *i;
}, 54); }, 54);
BOOST_CHECK_EQUAL(mapped, 42); BOOST_TEST(mapped == 42);
} }
{ {
const toml::result<int, std::string> result(toml::err<std::string>("hoge")); const toml::result<int, std::string> result(toml::err<std::string>("hoge"));
@@ -245,7 +245,7 @@ BOOST_AUTO_TEST_CASE(test_map_or_else)
return i * 2; return i * 2;
}, 54); }, 54);
BOOST_CHECK_EQUAL(mapped, 54); BOOST_TEST(mapped == 54);
} }
{ {
toml::result<std::unique_ptr<int>, std::string> toml::result<std::unique_ptr<int>, std::string>
@@ -255,7 +255,7 @@ BOOST_AUTO_TEST_CASE(test_map_or_else)
return *i; return *i;
}, 54); }, 54);
BOOST_CHECK_EQUAL(mapped, 54); BOOST_TEST(mapped == 54);
} }
} }
@@ -268,7 +268,7 @@ BOOST_AUTO_TEST_CASE(test_map_err_or_else)
return i + i; return i + i;
}, "foobar"); }, "foobar");
BOOST_CHECK_EQUAL(mapped, "foobar"); BOOST_TEST(mapped == "foobar");
} }
{ {
toml::result<std::unique_ptr<int>, std::string> toml::result<std::unique_ptr<int>, std::string>
@@ -278,7 +278,7 @@ BOOST_AUTO_TEST_CASE(test_map_err_or_else)
return i + i; return i + i;
}, "foobar"); }, "foobar");
BOOST_CHECK_EQUAL(mapped, "foobar"); BOOST_TEST(mapped == "foobar");
} }
{ {
const toml::result<int, std::string> result(toml::err<std::string>("hoge")); const toml::result<int, std::string> result(toml::err<std::string>("hoge"));
@@ -287,7 +287,7 @@ BOOST_AUTO_TEST_CASE(test_map_err_or_else)
return i + i; return i + i;
}, "foobar"); }, "foobar");
BOOST_CHECK_EQUAL(mapped, "hogehoge"); BOOST_TEST(mapped == "hogehoge");
} }
{ {
toml::result<std::unique_ptr<int>, std::string> toml::result<std::unique_ptr<int>, std::string>
@@ -297,7 +297,7 @@ BOOST_AUTO_TEST_CASE(test_map_err_or_else)
return i + i; return i + i;
}, "foobar"); }, "foobar");
BOOST_CHECK_EQUAL(mapped, "hogehoge"); BOOST_TEST(mapped == "hogehoge");
} }
} }
@@ -311,10 +311,10 @@ BOOST_AUTO_TEST_CASE(test_and_then)
return toml::ok(i * 2); return toml::ok(i * 2);
}); });
BOOST_CHECK(!!mapped); BOOST_TEST(!!mapped);
BOOST_CHECK(mapped.is_ok()); BOOST_TEST(mapped.is_ok());
BOOST_CHECK(!mapped.is_err()); BOOST_TEST(!mapped.is_err());
BOOST_CHECK_EQUAL(mapped.unwrap(), 42 * 2); BOOST_TEST(mapped.unwrap() == 42 * 2);
} }
{ {
toml::result<std::unique_ptr<int>, std::string> toml::result<std::unique_ptr<int>, std::string>
@@ -324,10 +324,10 @@ BOOST_AUTO_TEST_CASE(test_and_then)
return toml::ok(*i); return toml::ok(*i);
}); });
BOOST_CHECK(!!mapped); BOOST_TEST(!!mapped);
BOOST_CHECK(mapped.is_ok()); BOOST_TEST(mapped.is_ok());
BOOST_CHECK(!mapped.is_err()); BOOST_TEST(!mapped.is_err());
BOOST_CHECK_EQUAL(mapped.unwrap(), 42); BOOST_TEST(mapped.unwrap() == 42);
} }
{ {
const toml::result<int, std::string> result(toml::err<std::string>("hoge")); const toml::result<int, std::string> result(toml::err<std::string>("hoge"));
@@ -336,10 +336,10 @@ BOOST_AUTO_TEST_CASE(test_and_then)
return toml::ok(i * 2); return toml::ok(i * 2);
}); });
BOOST_CHECK(!mapped); BOOST_TEST(!mapped);
BOOST_CHECK(!mapped.is_ok()); BOOST_TEST(!mapped.is_ok());
BOOST_CHECK(mapped.is_err()); BOOST_TEST(mapped.is_err());
BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hoge"); BOOST_TEST(mapped.unwrap_err() == "hoge");
} }
{ {
toml::result<std::unique_ptr<int>, std::string> toml::result<std::unique_ptr<int>, std::string>
@@ -349,10 +349,10 @@ BOOST_AUTO_TEST_CASE(test_and_then)
return toml::ok(*i); return toml::ok(*i);
}); });
BOOST_CHECK(!mapped); BOOST_TEST(!mapped);
BOOST_CHECK(!mapped.is_ok()); BOOST_TEST(!mapped.is_ok());
BOOST_CHECK(mapped.is_err()); BOOST_TEST(mapped.is_err());
BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hoge"); BOOST_TEST(mapped.unwrap_err() == "hoge");
} }
} }
@@ -365,10 +365,10 @@ BOOST_AUTO_TEST_CASE(test_or_else)
return toml::err(s + s); return toml::err(s + s);
}); });
BOOST_CHECK(!!mapped); BOOST_TEST(!!mapped);
BOOST_CHECK(mapped.is_ok()); BOOST_TEST(mapped.is_ok());
BOOST_CHECK(!mapped.is_err()); BOOST_TEST(!mapped.is_err());
BOOST_CHECK_EQUAL(mapped.unwrap(), 42); BOOST_TEST(mapped.unwrap() == 42);
} }
{ {
toml::result<std::unique_ptr<int>, std::string> toml::result<std::unique_ptr<int>, std::string>
@@ -378,10 +378,10 @@ BOOST_AUTO_TEST_CASE(test_or_else)
return toml::err(s + s); return toml::err(s + s);
}); });
BOOST_CHECK(!!mapped); BOOST_TEST(!!mapped);
BOOST_CHECK(mapped.is_ok()); BOOST_TEST(mapped.is_ok());
BOOST_CHECK(!mapped.is_err()); BOOST_TEST(!mapped.is_err());
BOOST_CHECK_EQUAL(*mapped.unwrap(), 42); BOOST_TEST(*mapped.unwrap() == 42);
} }
{ {
const toml::result<int, std::string> result(toml::err<std::string>("hoge")); const toml::result<int, std::string> result(toml::err<std::string>("hoge"));
@@ -390,10 +390,10 @@ BOOST_AUTO_TEST_CASE(test_or_else)
return toml::err(s + s); return toml::err(s + s);
}); });
BOOST_CHECK(!mapped); BOOST_TEST(!mapped);
BOOST_CHECK(!mapped.is_ok()); BOOST_TEST(!mapped.is_ok());
BOOST_CHECK(mapped.is_err()); BOOST_TEST(mapped.is_err());
BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hogehoge"); BOOST_TEST(mapped.unwrap_err() == "hogehoge");
} }
{ {
toml::result<std::unique_ptr<int>, std::string> toml::result<std::unique_ptr<int>, std::string>
@@ -403,10 +403,10 @@ BOOST_AUTO_TEST_CASE(test_or_else)
return toml::err(s + s); return toml::err(s + s);
}); });
BOOST_CHECK(!mapped); BOOST_TEST(!mapped);
BOOST_CHECK(!mapped.is_ok()); BOOST_TEST(!mapped.is_ok());
BOOST_CHECK(mapped.is_err()); BOOST_TEST(mapped.is_err());
BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hogehoge"); BOOST_TEST(mapped.unwrap_err() == "hogehoge");
} }
} }
@@ -416,10 +416,10 @@ BOOST_AUTO_TEST_CASE(test_and_or_other)
const toml::result<int, std::string> r1(toml::ok(42)); const toml::result<int, std::string> r1(toml::ok(42));
const toml::result<int, std::string> r2(toml::err<std::string>("foo")); const toml::result<int, std::string> r2(toml::err<std::string>("foo"));
BOOST_CHECK_EQUAL(r1, r1.or_other(r2)); BOOST_TEST(r1 == r1.or_other(r2));
BOOST_CHECK_EQUAL(r2, r1.and_other(r2)); BOOST_TEST(r2 == r1.and_other(r2));
BOOST_CHECK_EQUAL(42, r1.or_other(r2).unwrap()); BOOST_TEST(42 == r1.or_other(r2).unwrap());
BOOST_CHECK_EQUAL("foo", r1.and_other(r2).unwrap_err()); BOOST_TEST("foo" == r1.and_other(r2).unwrap_err());
} }
{ {
auto r1_gen = []() -> toml::result<int, std::string> { auto r1_gen = []() -> toml::result<int, std::string> {
@@ -431,10 +431,10 @@ BOOST_AUTO_TEST_CASE(test_and_or_other)
const auto r3 = r1_gen(); const auto r3 = r1_gen();
const auto r4 = r2_gen(); const auto r4 = r2_gen();
BOOST_CHECK_EQUAL(r3, r1_gen().or_other (r2_gen())); BOOST_TEST(r3 == r1_gen().or_other (r2_gen()));
BOOST_CHECK_EQUAL(r4, r1_gen().and_other(r2_gen())); BOOST_TEST(r4 == r1_gen().and_other(r2_gen()));
BOOST_CHECK_EQUAL(42, r1_gen().or_other (r2_gen()).unwrap()); BOOST_TEST(42 == r1_gen().or_other (r2_gen()).unwrap());
BOOST_CHECK_EQUAL("foo", r1_gen().and_other(r2_gen()).unwrap_err()); BOOST_TEST("foo" == r1_gen().and_other(r2_gen()).unwrap_err());
} }
} }

114
tests/test_serialize_file.cpp
View File

@@ -19,15 +19,38 @@ BOOST_AUTO_TEST_CASE(test_example)
auto serialized = toml::parse("tmp1.toml"); auto serialized = toml::parse("tmp1.toml");
{ {
auto& owner = toml::find<toml::table>(serialized, "owner"); auto& owner = toml::find(serialized, "owner");
auto& bio = toml::get<std::string>(owner.at("bio")); auto& bio = toml::find<std::string>(owner, "bio");
const auto CR = std::find(bio.begin(), bio.end(), '\r'); const auto CR = std::find(bio.begin(), bio.end(), '\r');
if(CR != bio.end()) if(CR != bio.end())
{ {
bio.erase(CR); bio.erase(CR);
} }
} }
BOOST_CHECK(data == serialized); BOOST_TEST(data == serialized);
}
BOOST_AUTO_TEST_CASE(test_example_map_dq)
{
const auto data = toml::parse<toml::discard_comments, std::map, std::deque>(
"toml/tests/example.toml");
{
std::ofstream ofs("tmp1.toml");
ofs << std::setw(80) << data;
}
auto serialized = toml::parse<toml::discard_comments, std::map, std::deque>(
"tmp1.toml");
{
auto& owner = toml::find(serialized, "owner");
auto& bio = toml::find<std::string>(owner, "bio");
const auto CR = std::find(bio.begin(), bio.end(), '\r');
if(CR != bio.end())
{
bio.erase(CR);
}
}
BOOST_TEST(data == serialized);
} }
BOOST_AUTO_TEST_CASE(test_example_with_comment) BOOST_AUTO_TEST_CASE(test_example_with_comment)
@@ -40,15 +63,42 @@ BOOST_AUTO_TEST_CASE(test_example_with_comment)
auto serialized = toml::parse<toml::preserve_comments>("tmp1_com.toml"); auto serialized = toml::parse<toml::preserve_comments>("tmp1_com.toml");
{ {
auto& owner = toml::find<typename decltype(serialized)::table_type>(serialized, "owner"); auto& owner = toml::find(serialized, "owner");
auto& bio = toml::get<std::string>(owner.at("bio")); auto& bio = toml::find<std::string>(owner, "bio");
const auto CR = std::find(bio.begin(), bio.end(), '\r'); const auto CR = std::find(bio.begin(), bio.end(), '\r');
if(CR != bio.end()) if(CR != bio.end())
{ {
bio.erase(CR); bio.erase(CR);
} }
} }
BOOST_CHECK(data == serialized); BOOST_TEST(data == serialized);
{
std::ofstream ofs("tmp1_com1.toml");
ofs << std::setw(80) << serialized;
}
}
BOOST_AUTO_TEST_CASE(test_example_with_comment_map_dq)
{
const auto data = toml::parse<toml::preserve_comments, std::map, std::deque>(
"toml/tests/example.toml");
{
std::ofstream ofs("tmp1_com.toml");
ofs << std::setw(80) << data;
}
auto serialized = toml::parse<toml::preserve_comments, std::map, std::deque>(
"tmp1_com.toml");
{
auto& owner = toml::find(serialized, "owner");
auto& bio = toml::find<std::string>(owner, "bio");
const auto CR = std::find(bio.begin(), bio.end(), '\r');
if(CR != bio.end())
{
bio.erase(CR);
}
}
BOOST_TEST(data == serialized);
{ {
std::ofstream ofs("tmp1_com1.toml"); std::ofstream ofs("tmp1_com1.toml");
ofs << std::setw(80) << serialized; ofs << std::setw(80) << serialized;
@@ -63,7 +113,20 @@ BOOST_AUTO_TEST_CASE(test_fruit)
ofs << std::setw(80) << data; ofs << std::setw(80) << data;
} }
const auto serialized = toml::parse("tmp2.toml"); const auto serialized = toml::parse("tmp2.toml");
BOOST_CHECK(data == serialized); BOOST_TEST(data == serialized);
}
BOOST_AUTO_TEST_CASE(test_fruit_map_dq)
{
const auto data = toml::parse<toml::discard_comments, std::map, std::deque>(
"toml/tests/fruit.toml");
{
std::ofstream ofs("tmp2.toml");
ofs << std::setw(80) << data;
}
const auto serialized = toml::parse<toml::discard_comments, std::map, std::deque>(
"tmp2.toml");
BOOST_TEST(data == serialized);
} }
BOOST_AUTO_TEST_CASE(test_fruit_with_comments) BOOST_AUTO_TEST_CASE(test_fruit_with_comments)
@@ -74,7 +137,19 @@ BOOST_AUTO_TEST_CASE(test_fruit_with_comments)
ofs << std::setw(80) << data; ofs << std::setw(80) << data;
} }
const auto serialized = toml::parse<toml::preserve_comments>("tmp2_com.toml"); const auto serialized = toml::parse<toml::preserve_comments>("tmp2_com.toml");
BOOST_CHECK(data == serialized); BOOST_TEST(data == serialized);
}
BOOST_AUTO_TEST_CASE(test_fruit_with_comments_map_dq)
{
const auto data = toml::parse<toml::preserve_comments, std::map, std::deque>(
"toml/tests/fruit.toml");
{
std::ofstream ofs("tmp2_com.toml");
ofs << std::setw(80) << data;
}
const auto serialized = toml::parse<toml::preserve_comments, std::map, std::deque>("tmp2_com.toml");
BOOST_TEST(data == serialized);
} }
BOOST_AUTO_TEST_CASE(test_hard_example) BOOST_AUTO_TEST_CASE(test_hard_example)
@@ -85,20 +160,35 @@ BOOST_AUTO_TEST_CASE(test_hard_example)
ofs << std::setw(80) << data; ofs << std::setw(80) << data;
} }
const auto serialized = toml::parse("tmp3.toml"); const auto serialized = toml::parse("tmp3.toml");
BOOST_CHECK(data == serialized); BOOST_TEST(data == serialized);
}
BOOST_AUTO_TEST_CASE(test_hard_example_map_dq)
{
const auto data = toml::parse<toml::discard_comments, std::map, std::deque>(
"toml/tests/hard_example.toml");
{
std::ofstream ofs("tmp3.toml");
ofs << std::setw(80) << data;
}
const auto serialized = toml::parse<toml::discard_comments, std::map, std::deque>(
"tmp3.toml");
BOOST_TEST(data == serialized);
} }
BOOST_AUTO_TEST_CASE(test_hard_example_with_comment) BOOST_AUTO_TEST_CASE(test_hard_example_with_comment)
{ {
const auto data = toml::parse<toml::preserve_comments>("toml/tests/hard_example.toml"); const auto data = toml::parse<toml::preserve_comments, std::map, std::deque>(
"toml/tests/hard_example.toml");
{ {
std::ofstream ofs("tmp3_com.toml"); std::ofstream ofs("tmp3_com.toml");
ofs << std::setw(80) << data; ofs << std::setw(80) << data;
} }
const auto serialized = toml::parse<toml::preserve_comments>("tmp3_com.toml"); const auto serialized = toml::parse<toml::preserve_comments, std::map, std::deque>(
"tmp3_com.toml");
{ {
std::ofstream ofs("tmp3_com1.toml"); std::ofstream ofs("tmp3_com1.toml");
ofs << std::setw(80) << serialized; ofs << std::setw(80) << serialized;
} }
BOOST_CHECK(data == serialized); BOOST_TEST(data == serialized);
} }

1077
tests/test_value.cpp
View File

File diff suppressed because it is too large Load Diff