diff --git a/tests/test_lex_aux.hpp b/tests/test_lex_aux.hpp index 8585c38..c0d2b16 100644 --- a/tests/test_lex_aux.hpp +++ b/tests/test_lex_aux.hpp @@ -10,17 +10,17 @@ do { \ const std::string expected(expct); \ toml::detail::location loc("test", token); \ const auto result = lxr::invoke(loc); \ - BOOST_CHECK(result.is_ok()); \ + BOOST_TEST(result.is_ok()); \ if(result.is_ok()){ \ - const auto region = result.unwrap(); \ - BOOST_CHECK_EQUAL(region.str(), expected); \ - BOOST_CHECK_EQUAL(region.str().size(), expected.size()); \ - BOOST_CHECK_EQUAL(static_cast(std::distance( \ - loc.begin(), loc.iter())), region.size()); \ + const auto region = result.unwrap(); \ + BOOST_TEST(region.str() == expected); \ + BOOST_TEST(region.str().size() == expected.size()); \ + BOOST_TEST(static_cast(std::distance( \ + loc.begin(), loc.iter())) == region.size()); \ } else { \ - std::cerr << "lexer failed with input `"; \ - std::cerr << token << "`. expected `" << expected << "`\n"; \ - std::cerr << "reason: " << result.unwrap_err() << '\n'; \ + std::cerr << "lexer failed with input `"; \ + std::cerr << token << "`. expected `" << expected << "`\n"; \ + std::cerr << "reason: " << result.unwrap_err() << '\n'; \ } \ } while(false); \ /**/ @@ -30,6 +30,7 @@ do { \ const std::string token (tkn); \ toml::detail::location loc("test", token); \ const auto result = lxr::invoke(loc); \ - BOOST_CHECK(result.is_err()); \ - BOOST_CHECK(loc.begin() == loc.iter()); \ + BOOST_TEST(result.is_err()); \ + const bool loc_same = (loc.begin() == loc.iter()); \ + BOOST_TEST(loc_same); \ } while(false); /**/ diff --git a/tests/test_literals.cpp b/tests/test_literals.cpp index 3323168..f90f598 100644 --- a/tests/test_literals.cpp +++ b/tests/test_literals.cpp @@ -19,7 +19,7 @@ BOOST_AUTO_TEST_CASE(test_file_as_literal) b = "baz" )"_toml; - BOOST_CHECK_EQUAL(r, v); + BOOST_TEST(r == v); } { const toml::value r{ @@ -33,7 +33,7 @@ BOOST_AUTO_TEST_CASE(test_file_as_literal) b = "baz" )"_toml; - BOOST_CHECK_EQUAL(r, v); + BOOST_TEST(r == v); } { const toml::value r{ @@ -45,7 +45,7 @@ BOOST_AUTO_TEST_CASE(test_file_as_literal) b = "baz" )"_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 v2 = u8"false"_toml; - BOOST_CHECK(v1.is_boolean()); - BOOST_CHECK(v2.is_boolean()); - BOOST_CHECK(toml::get(v1)); - BOOST_CHECK(!toml::get(v2)); + BOOST_TEST(v1.is_boolean()); + BOOST_TEST(v2.is_boolean()); + BOOST_TEST(toml::get(v1)); + BOOST_TEST(!toml::get(v2)); } { const toml::value v1 = u8"123_456"_toml; const toml::value v2 = u8"0b0010"_toml; const toml::value v3 = u8"0xDEADBEEF"_toml; - BOOST_CHECK(v1.is_integer()); - BOOST_CHECK(v2.is_integer()); - BOOST_CHECK(v3.is_integer()); - BOOST_CHECK_EQUAL(toml::get(v1), 123456); - BOOST_CHECK_EQUAL(toml::get(v2), 2); - BOOST_CHECK_EQUAL(toml::get(v3), 0xDEADBEEF); + BOOST_TEST(v1.is_integer()); + BOOST_TEST(v2.is_integer()); + BOOST_TEST(v3.is_integer()); + BOOST_TEST(toml::get(v1) == 123456); + BOOST_TEST(toml::get(v2) == 2); + BOOST_TEST(toml::get(v3) == 0xDEADBEEF); } { const toml::value v1 = u8"3.1415"_toml; const toml::value v2 = u8"6.02e+23"_toml; - BOOST_CHECK(v1.is_floating()); - BOOST_CHECK(v2.is_floating()); - BOOST_CHECK_CLOSE(toml::get(v1), 3.1415, 0.00001); - BOOST_CHECK_CLOSE(toml::get(v2), 6.02e23, 0.0001); + BOOST_TEST(v1.is_floating()); + BOOST_TEST(v2.is_floating()); + BOOST_TEST(toml::get(v1) == 3.1415, boost::test_tools::tolerance(0.00001)); + BOOST_TEST(toml::get(v2) == 6.02e23, boost::test_tools::tolerance(0.0001)); } { 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 v4 = u8R"('''foo''')"_toml; - BOOST_CHECK(v1.is_string()); - BOOST_CHECK(v2.is_string()); - BOOST_CHECK(v3.is_string()); - BOOST_CHECK(v4.is_string()); - BOOST_CHECK_EQUAL(toml::get(v1), "foo"); - BOOST_CHECK_EQUAL(toml::get(v2), "foo"); - BOOST_CHECK_EQUAL(toml::get(v3), "foo"); - BOOST_CHECK_EQUAL(toml::get(v4), "foo"); + BOOST_TEST(v1.is_string()); + BOOST_TEST(v2.is_string()); + BOOST_TEST(v3.is_string()); + BOOST_TEST(v4.is_string()); + BOOST_TEST(toml::get(v1) == "foo"); + BOOST_TEST(toml::get(v2) == "foo"); + BOOST_TEST(toml::get(v3) == "foo"); + BOOST_TEST(toml::get(v4) == "foo"); } { - const toml::value v1 = u8R"([1,2,3])"_toml; - - BOOST_CHECK(v1.is_array()); - BOOST_CHECK((toml::get>(v1) == std::vector{1,2,3})); - - const toml::value v2 = u8R"([1,])"_toml; - - BOOST_CHECK(v2.is_array()); - BOOST_CHECK((toml::get>(v2) == std::vector{1})); - - const toml::value v3 = u8R"([[1,]])"_toml; - BOOST_CHECK(v3.is_array()); - BOOST_CHECK((toml::get>(toml::get(v3).front()) == std::vector{1})); - - const toml::value v4 = u8R"([[1],])"_toml; - BOOST_CHECK(v4.is_array()); - BOOST_CHECK((toml::get>(toml::get(v4).front()) == std::vector{1})); + { + const toml::value v1 = u8R"([1,2,3])"_toml; + BOOST_TEST(v1.is_array()); + const bool result = (toml::get>(v1) == std::vector{1,2,3}); + BOOST_TEST(result); + } + { + const toml::value v2 = u8R"([1,])"_toml; + BOOST_TEST(v2.is_array()); + const bool result = (toml::get>(v2) == std::vector{1}); + BOOST_TEST(result); + } + { + const toml::value v3 = u8R"([[1,]])"_toml; + BOOST_TEST(v3.is_array()); + const bool result = (toml::get>(toml::get(v3).front()) == std::vector{1}); + BOOST_TEST(result); + } + { + const toml::value v4 = u8R"([[1],])"_toml; + BOOST_TEST(v4.is_array()); + const bool result = (toml::get>(toml::get(v4).front()) == std::vector{1}); + BOOST_TEST(result); + } } { const toml::value v1 = u8R"({a = 42})"_toml; - BOOST_CHECK(v1.is_table()); - BOOST_CHECK((toml::get>(v1) == - std::map{{"a", 42}})); + BOOST_TEST(v1.is_table()); + const bool result = toml::get>(v1) == + std::map{{"a", 42}}; + BOOST_TEST(result); } { const toml::value v1 = u8"1979-05-27"_toml; - BOOST_CHECK(v1.is_local_date()); - BOOST_CHECK_EQUAL(toml::get(v1), - toml::local_date(1979, toml::month_t::May, 27)); + BOOST_TEST(v1.is_local_date()); + BOOST_TEST(toml::get(v1) == + toml::local_date(1979, toml::month_t::May, 27)); } { const toml::value v1 = u8"12:00:00"_toml; - BOOST_CHECK(v1.is_local_time()); - BOOST_CHECK(toml::get(v1) == std::chrono::hours(12)); + BOOST_TEST(v1.is_local_time()); + const bool result = toml::get(v1) == std::chrono::hours(12); + BOOST_TEST(result); } { const toml::value v1 = u8"1979-05-27T07:32:00"_toml; - BOOST_CHECK(v1.is_local_datetime()); - BOOST_CHECK_EQUAL(toml::get(v1), + BOOST_TEST(v1.is_local_datetime()); + BOOST_TEST(toml::get(v1) == toml::local_datetime(toml::local_date(1979, toml::month_t::May, 27), toml::local_time(7, 32, 0))); } { const toml::value v1 = "1979-05-27T07:32:00Z"_toml; - BOOST_CHECK(v1.is_offset_datetime()); - BOOST_CHECK_EQUAL(toml::get(v1), + BOOST_TEST(v1.is_offset_datetime()); + BOOST_TEST(toml::get(v1) == toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27), toml::local_time(7, 32, 0), toml::time_offset(0, 0))); } diff --git a/tests/test_parse_aux.hpp b/tests/test_parse_aux.hpp index 4ef9541..6702181 100644 --- a/tests/test_parse_aux.hpp +++ b/tests/test_parse_aux.hpp @@ -1,8 +1,7 @@ #include #include #include -#include -#include +#include // some of the parsers returns not only a value but also a region. #define TOML11_TEST_PARSE_EQUAL(psr, tkn, expct) \ @@ -10,13 +9,13 @@ do { \ const std::string token(tkn); \ toml::detail::location loc("test", token); \ const auto result = psr(loc); \ - BOOST_CHECK(result.is_ok()); \ + BOOST_TEST(result.is_ok()); \ if(result.is_ok()){ \ - BOOST_CHECK(result.unwrap().first == expct); \ + BOOST_TEST(result.unwrap().first == expct); \ } else { \ - std::cerr << "parser " << #psr << " failed with input `"; \ - std::cerr << token << "`.\n"; \ - std::cerr << "reason: " << result.unwrap_err() << '\n'; \ + std::cerr << "parser " << #psr << " failed with input `"; \ + std::cerr << token << "`.\n"; \ + std::cerr << "reason: " << result.unwrap_err() << '\n'; \ } \ } while(false); \ /**/ @@ -26,13 +25,13 @@ do { \ const std::string token(tkn); \ toml::detail::location loc("test", token); \ const auto result = psr(loc); \ - BOOST_CHECK(result.is_ok()); \ + BOOST_TEST(result.is_ok()); \ if(result.is_ok()){ \ - BOOST_CHECK(result.unwrap() == expct); \ + BOOST_TEST(result.unwrap() == expct); \ } else { \ - std::cerr << "parse_value failed with input `"; \ - std::cerr << token << "`.\n"; \ - std::cerr << "reason: " << result.unwrap_err() << '\n'; \ + std::cerr << "parse_value failed with input `"; \ + std::cerr << token << "`.\n"; \ + std::cerr << "reason: " << result.unwrap_err() << '\n'; \ } \ } while(false); \ /**/ diff --git a/tests/test_parse_file.cpp b/tests/test_parse_file.cpp index 518a98c..0e8c781 100644 --- a/tests/test_parse_file.cpp +++ b/tests/test_parse_file.cpp @@ -15,67 +15,66 @@ BOOST_AUTO_TEST_CASE(test_example) { const auto data = toml::parse("toml/tests/example.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "title"), "TOML Example"); + BOOST_TEST(toml::find(data, "title") == "TOML Example"); const auto& owner = toml::find(data, "owner"); { - BOOST_CHECK_EQUAL(toml::find(owner, "name"), "Tom Preston-Werner"); - BOOST_CHECK_EQUAL(toml::find(owner, "organization"), "GitHub"); - BOOST_CHECK_EQUAL(toml::find(owner, "bio"), + BOOST_TEST(toml::find(owner, "name") == "Tom Preston-Werner"); + BOOST_TEST(toml::find(owner, "organization") == "GitHub"); + BOOST_TEST(toml::find(owner, "bio") == "GitHub Cofounder & CEO\nLikes tater tots and beer."); - BOOST_CHECK_EQUAL(toml::find(owner, "dob"), + BOOST_TEST(toml::find(owner, "dob") == toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27), toml::local_time(7, 32, 0), toml::time_offset(0, 0))); } const auto& database = toml::find(data, "database"); { - BOOST_CHECK_EQUAL(toml::find(database, "server"), "192.168.1.1"); + BOOST_TEST(toml::find(database, "server") == "192.168.1.1"); const std::vector expected_ports{8001, 8001, 8002}; - BOOST_CHECK(toml::find>(database, "ports") == expected_ports); - BOOST_CHECK_EQUAL(toml::find(database, "connection_max"), 5000); - BOOST_CHECK_EQUAL(toml::find(database, "enabled"), true); + const bool result = toml::find>(database, "ports") == expected_ports; + BOOST_TEST(result); + BOOST_TEST(toml::find(database, "connection_max") == 5000); + BOOST_TEST(toml::find(database, "enabled") == true); } const auto& servers = toml::find(data, "servers"); { toml::table alpha = toml::find(servers, "alpha"); - BOOST_CHECK_EQUAL(toml::get(alpha.at("ip")), "10.0.0.1"); - BOOST_CHECK_EQUAL(toml::get(alpha.at("dc")), "eqdc10"); + BOOST_TEST(toml::get(alpha.at("ip")) == "10.0.0.1"); + BOOST_TEST(toml::get(alpha.at("dc")) == "eqdc10"); toml::table beta = toml::find(servers, "beta"); - BOOST_CHECK_EQUAL(toml::get(beta.at("ip")), "10.0.0.2"); - BOOST_CHECK_EQUAL(toml::get(beta.at("dc")), "eqdc10"); - BOOST_CHECK_EQUAL(toml::get(beta.at("country")), "\xE4\xB8\xAD\xE5\x9B\xBD"); + BOOST_TEST(toml::get(beta.at("ip")) == "10.0.0.2"); + BOOST_TEST(toml::get(beta.at("dc")) == "eqdc10"); + BOOST_TEST(toml::get(beta.at("country")) == "\xE4\xB8\xAD\xE5\x9B\xBD"); } const auto& clients = toml::find(data, "clients"); { toml::array clients_data = toml::find(clients, "data"); + std::vector expected_name{"gamma", "delta"}; - BOOST_CHECK(toml::get>(clients_data.at(0)) == - expected_name); + const bool result1 = toml::get>(clients_data.at(0)) == expected_name; + BOOST_TEST(reuslt1); + std::vector expected_number{1, 2}; - BOOST_CHECK(toml::get>(clients_data.at(1)) == - expected_number); + const bool result2 = toml::get>(clients_data.at(1)) == expected_number; + BOOST_TEST(reuslt2); + std::vector expected_hosts{"alpha", "omega"}; - BOOST_CHECK(toml::find>(clients, "hosts") == - expected_hosts); + const bool result3 = toml::find>(clients, "hosts") == expected_hosts; + BOOST_TEST(reuslt3); } std::vector products = toml::find>(data, "products"); { - BOOST_CHECK_EQUAL(toml::get(products.at(0).at("name")), - "Hammer"); - BOOST_CHECK_EQUAL(toml::get(products.at(0).at("sku")), - 738594937); + BOOST_TEST(toml::get(products.at(0).at("name")) == "Hammer"); + BOOST_TEST(toml::get(products.at(0).at("sku")) == 738594937); - BOOST_CHECK_EQUAL(toml::get(products.at(1).at("name")), - "Nail"); - BOOST_CHECK_EQUAL(toml::get(products.at(1).at("sku")), - 284758393); - BOOST_CHECK_EQUAL(toml::get(products.at(1).at("color")), - "gray"); + BOOST_TEST(toml::get(products.at(1).at("name")) == "Nail"); + BOOST_TEST(toml::get(products.at(1).at("sku")) == 284758393); + BOOST_TEST(toml::get(products.at(1).at("color")) == "gray"); } } @@ -84,66 +83,69 @@ BOOST_AUTO_TEST_CASE(test_example_stream) std::ifstream ifs("toml/tests/example.toml"); const auto data = toml::parse(ifs); - BOOST_CHECK_EQUAL(toml::find(data, "title"), "TOML Example"); + BOOST_TEST(toml::find(data, "title") == "TOML Example"); const auto& owner = toml::find(data, "owner"); { - BOOST_CHECK_EQUAL(toml::find(owner, "name"), "Tom Preston-Werner"); - BOOST_CHECK_EQUAL(toml::find(owner, "organization"), "GitHub"); - BOOST_CHECK_EQUAL(toml::find(owner, "bio"), + BOOST_TEST(toml::find(owner, "name") == "Tom Preston-Werner"); + BOOST_TEST(toml::find(owner, "organization") == "GitHub"); + BOOST_TEST(toml::find(owner, "bio") == "GitHub Cofounder & CEO\nLikes tater tots and beer."); - BOOST_CHECK_EQUAL(toml::find(owner, "dob"), + BOOST_TEST(toml::find(owner, "dob") == toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27), toml::local_time(7, 32, 0), toml::time_offset(0, 0))); } const auto& database = toml::find(data, "database"); { - BOOST_CHECK_EQUAL(toml::find(database, "server"), "192.168.1.1"); + BOOST_TEST(toml::find(database, "server") == "192.168.1.1"); const std::vector expected_ports{8001, 8001, 8002}; - BOOST_CHECK(toml::find>(database, "ports") == expected_ports); - BOOST_CHECK_EQUAL(toml::find(database, "connection_max"), 5000); - BOOST_CHECK_EQUAL(toml::find(database, "enabled"), true); + const bool result = (toml::find>(database, "ports") == expected_ports); + BOOST_TEST(result); + BOOST_TEST(toml::find(database, "connection_max") == 5000); + BOOST_TEST(toml::find(database, "enabled") == true); } const auto& servers = toml::find(data, "servers"); { toml::table alpha = toml::find(servers, "alpha"); - BOOST_CHECK_EQUAL(toml::get(alpha.at("ip")), "10.0.0.1"); - BOOST_CHECK_EQUAL(toml::get(alpha.at("dc")), "eqdc10"); + BOOST_TEST(toml::get(alpha.at("ip")) == "10.0.0.1"); + BOOST_TEST(toml::get(alpha.at("dc")) == "eqdc10"); toml::table beta = toml::find(servers, "beta"); - BOOST_CHECK_EQUAL(toml::get(beta.at("ip")), "10.0.0.2"); - BOOST_CHECK_EQUAL(toml::get(beta.at("dc")), "eqdc10"); - BOOST_CHECK_EQUAL(toml::get(beta.at("country")), "\xE4\xB8\xAD\xE5\x9B\xBD"); + BOOST_TEST(toml::get(beta.at("ip")) == "10.0.0.2"); + BOOST_TEST(toml::get(beta.at("dc")) == "eqdc10"); + BOOST_TEST(toml::get(beta.at("country")) == "\xE4\xB8\xAD\xE5\x9B\xBD"); } const auto& clients = toml::find(data, "clients"); { toml::array clients_data = toml::find(clients, "data"); std::vector expected_name{"gamma", "delta"}; - BOOST_CHECK(toml::get>(clients_data.at(0)) == - expected_name); + const bool result1 = toml::get>(clients_data.at(0)) == expected_name; + BOOST_TEST(reuslt1); + std::vector expected_number{1, 2}; - BOOST_CHECK(toml::get>(clients_data.at(1)) == - expected_number); + const bool result2 = toml::get>(clients_data.at(1)) == expected_number; + BOOST_TEST(reuslt2); + std::vector expected_hosts{"alpha", "omega"}; - BOOST_CHECK(toml::find>(clients, "hosts") == - expected_hosts); + const bool result3 = toml::find>(clients, "hosts") == expected_hosts; + BOOST_TEST(reuslt3); } std::vector products = toml::find>(data, "products"); { - BOOST_CHECK_EQUAL(toml::get(products.at(0).at("name")), + BOOST_TEST(toml::get(products.at(0).at("name")) == "Hammer"); - BOOST_CHECK_EQUAL(toml::get(products.at(0).at("sku")), + BOOST_TEST(toml::get(products.at(0).at("sku")) == 738594937); - BOOST_CHECK_EQUAL(toml::get(products.at(1).at("name")), + BOOST_TEST(toml::get(products.at(1).at("name")) == "Nail"); - BOOST_CHECK_EQUAL(toml::get(products.at(1).at("sku")), + BOOST_TEST(toml::get(products.at(1).at("sku")) == 284758393); - BOOST_CHECK_EQUAL(toml::get(products.at(1).at("color")), + BOOST_TEST(toml::get(products.at(1).at("color")) == "gray"); } } @@ -152,17 +154,17 @@ BOOST_AUTO_TEST_CASE(test_fruit) { const auto data = toml::parse("toml/tests/fruit.toml"); const auto blah = toml::find(toml::find(data, "fruit"), "blah"); - BOOST_CHECK_EQUAL(toml::find(blah.at(0), "name"), "apple"); - BOOST_CHECK_EQUAL(toml::find(blah.at(1), "name"), "banana"); + BOOST_TEST(toml::find(blah.at(0), "name") == "apple"); + BOOST_TEST(toml::find(blah.at(1), "name") == "banana"); { const auto physical = toml::find(blah.at(0), "physical"); - BOOST_CHECK_EQUAL(toml::find(physical, "color"), "red"); - BOOST_CHECK_EQUAL(toml::find(physical, "shape"), "round"); + BOOST_TEST(toml::find(physical, "color") == "red"); + BOOST_TEST(toml::find(physical, "shape") == "round"); } { const auto physical = toml::find(blah.at(1), "physical"); - BOOST_CHECK_EQUAL(toml::find(physical, "color"), "yellow"); - BOOST_CHECK_EQUAL(toml::find(physical, "shape"), "bent"); + BOOST_TEST(toml::find(physical, "color") == "yellow"); + BOOST_TEST(toml::find(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 the = toml::find(data, "the"); - BOOST_CHECK_EQUAL(toml::find(the, "test_string"), + BOOST_TEST(toml::find(the, "test_string") == "You'll hate me after this - #"); 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"}; BOOST_CHECK(toml::find>(hard, "test_array2") == expected_the_hard_test_array2); - BOOST_CHECK_EQUAL(toml::find(hard, "another_test_string"), + BOOST_TEST(toml::find(hard, "another_test_string") == " Same thing, but with a string #"); - BOOST_CHECK_EQUAL(toml::find(hard, "harder_test_string"), + BOOST_TEST(toml::find(hard, "harder_test_string") == " And when \"'s are in the string, along with # \""); const auto bit = toml::find(hard, "bit#"); - BOOST_CHECK_EQUAL(toml::find(bit, "what?"), + BOOST_TEST(toml::find(bit, "what?") == "You don't think some user won't do that?"); const std::vector expected_multi_line_array{"]"}; BOOST_CHECK(toml::find>(bit, "multi_line_array") == @@ -197,7 +199,7 @@ BOOST_AUTO_TEST_CASE(test_hard_example_comment) { const auto data = toml::parse("toml/tests/hard_example.toml"); const auto the = toml::find(data, "the"); - BOOST_CHECK_EQUAL(toml::find(the, "test_string"), + BOOST_TEST(toml::find(the, "test_string") == "You'll hate me after this - #"); 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"}; BOOST_CHECK(toml::find>(hard, "test_array2") == expected_the_hard_test_array2); - BOOST_CHECK_EQUAL(toml::find(hard, "another_test_string"), + BOOST_TEST(toml::find(hard, "another_test_string") == " Same thing, but with a string #"); - BOOST_CHECK_EQUAL(toml::find(hard, "harder_test_string"), + BOOST_TEST(toml::find(hard, "harder_test_string") == " And when \"'s are in the string, along with # \""); const auto bit = toml::find(hard, "bit#"); - BOOST_CHECK_EQUAL(toml::find(bit, "what?"), + BOOST_TEST(toml::find(bit, "what?") == "You don't think some user won't do that?"); const std::vector expected_multi_line_array{"]"}; BOOST_CHECK(toml::find>(bit, "multi_line_array") == @@ -226,49 +228,49 @@ BOOST_AUTO_TEST_CASE(test_example_preserve_comment) { const auto data = toml::parse("toml/tests/example.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "title"), "TOML Example"); + BOOST_TEST(toml::find(data, "title") == "TOML Example"); const auto& owner = toml::find(data, "owner"); { - BOOST_CHECK_EQUAL(toml::find(owner, "name"), "Tom Preston-Werner"); - BOOST_CHECK_EQUAL(toml::find(owner, "organization"), "GitHub"); - BOOST_CHECK_EQUAL(toml::find(owner, "bio"), + BOOST_TEST(toml::find(owner, "name") == "Tom Preston-Werner"); + BOOST_TEST(toml::find(owner, "organization") == "GitHub"); + BOOST_TEST(toml::find(owner, "bio") == "GitHub Cofounder & CEO\nLikes tater tots and beer."); - BOOST_CHECK_EQUAL(toml::find(owner, "dob"), + BOOST_TEST(toml::find(owner, "dob") == toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27), 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?"); } const auto& database = toml::find(data, "database"); { - BOOST_CHECK_EQUAL(toml::find(database, "server"), "192.168.1.1"); + BOOST_TEST(toml::find(database, "server") == "192.168.1.1"); const std::vector expected_ports{8001, 8001, 8002}; BOOST_CHECK(toml::find>(database, "ports") == expected_ports); - BOOST_CHECK_EQUAL(toml::find(database, "connection_max"), 5000); - BOOST_CHECK_EQUAL(toml::find(database, "enabled"), true); + BOOST_TEST(toml::find(database, "connection_max") == 5000); + BOOST_TEST(toml::find(database, "enabled") == true); } const auto& servers = toml::find(data, "servers"); { 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."); - BOOST_CHECK_EQUAL(toml::find(alpha, "ip"), "10.0.0.1"); - BOOST_CHECK_EQUAL(toml::find(alpha, "dc"), "eqdc10"); + BOOST_TEST(toml::find(alpha, "ip") == "10.0.0.1"); + BOOST_TEST(toml::find(alpha, "dc") == "eqdc10"); const auto& beta = toml::find(servers, "beta"); - BOOST_CHECK_EQUAL(toml::find(beta, "ip"), "10.0.0.2"); - BOOST_CHECK_EQUAL(toml::find(beta, "dc"), "eqdc10"); - BOOST_CHECK_EQUAL(toml::find(beta, "country"), + BOOST_TEST(toml::find(beta, "ip") == "10.0.0.2"); + BOOST_TEST(toml::find(beta, "dc") == "eqdc10"); + BOOST_TEST(toml::find(beta, "country") == "\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"); } 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"); @@ -283,23 +285,23 @@ BOOST_AUTO_TEST_CASE(test_example_preserve_comment) BOOST_CHECK(toml::find>(clients, "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"); } std::vector products = toml::find>(data, "products"); { - BOOST_CHECK_EQUAL(toml::get(products.at(0).at("name")), + BOOST_TEST(toml::get(products.at(0).at("name")) == "Hammer"); - BOOST_CHECK_EQUAL(toml::get(products.at(0).at("sku")), + BOOST_TEST(toml::get(products.at(0).at("sku")) == 738594937); - BOOST_CHECK_EQUAL(toml::get(products.at(1).at("name")), + BOOST_TEST(toml::get(products.at(1).at("name")) == "Nail"); - BOOST_CHECK_EQUAL(toml::get(products.at(1).at("sku")), + BOOST_TEST(toml::get(products.at(1).at("sku")) == 284758393); - BOOST_CHECK_EQUAL(toml::get(products.at(1).at("color")), + BOOST_TEST(toml::get(products.at(1).at("color")) == "gray"); } } @@ -316,49 +318,49 @@ BOOST_AUTO_TEST_CASE(test_example_preserve_stdmap_stddeque) std::deque::type> >::value, ""); - BOOST_CHECK_EQUAL(toml::find(data, "title"), "TOML Example"); + BOOST_TEST(toml::find(data, "title") == "TOML Example"); const auto& owner = toml::find(data, "owner"); { - BOOST_CHECK_EQUAL(toml::find(owner, "name"), "Tom Preston-Werner"); - BOOST_CHECK_EQUAL(toml::find(owner, "organization"), "GitHub"); - BOOST_CHECK_EQUAL(toml::find(owner, "bio"), + BOOST_TEST(toml::find(owner, "name") == "Tom Preston-Werner"); + BOOST_TEST(toml::find(owner, "organization") == "GitHub"); + BOOST_TEST(toml::find(owner, "bio") == "GitHub Cofounder & CEO\nLikes tater tots and beer."); - BOOST_CHECK_EQUAL(toml::find(owner, "dob"), + BOOST_TEST(toml::find(owner, "dob") == toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27), 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?"); } const auto& database = toml::find(data, "database"); { - BOOST_CHECK_EQUAL(toml::find(database, "server"), "192.168.1.1"); + BOOST_TEST(toml::find(database, "server") == "192.168.1.1"); const std::vector expected_ports{8001, 8001, 8002}; BOOST_CHECK(toml::find>(database, "ports") == expected_ports); - BOOST_CHECK_EQUAL(toml::find(database, "connection_max"), 5000); - BOOST_CHECK_EQUAL(toml::find(database, "enabled"), true); + BOOST_TEST(toml::find(database, "connection_max") == 5000); + BOOST_TEST(toml::find(database, "enabled") == true); } const auto& servers = toml::find(data, "servers"); { 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."); - BOOST_CHECK_EQUAL(toml::find(alpha, "ip"), "10.0.0.1"); - BOOST_CHECK_EQUAL(toml::find(alpha, "dc"), "eqdc10"); + BOOST_TEST(toml::find(alpha, "ip") == "10.0.0.1"); + BOOST_TEST(toml::find(alpha, "dc") == "eqdc10"); const auto& beta = toml::find(servers, "beta"); - BOOST_CHECK_EQUAL(toml::find(beta, "ip"), "10.0.0.2"); - BOOST_CHECK_EQUAL(toml::find(beta, "dc"), "eqdc10"); - BOOST_CHECK_EQUAL(toml::find(beta, "country"), + BOOST_TEST(toml::find(beta, "ip") == "10.0.0.2"); + BOOST_TEST(toml::find(beta, "dc") == "eqdc10"); + BOOST_TEST(toml::find(beta, "country") == "\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"); } 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"); @@ -373,23 +375,23 @@ BOOST_AUTO_TEST_CASE(test_example_preserve_stdmap_stddeque) BOOST_CHECK(toml::find>(clients, "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"); } std::vector products = toml::find>(data, "products"); { - BOOST_CHECK_EQUAL(toml::get(products.at(0).at("name")), + BOOST_TEST(toml::get(products.at(0).at("name")) == "Hammer"); - BOOST_CHECK_EQUAL(toml::get(products.at(0).at("sku")), + BOOST_TEST(toml::get(products.at(0).at("sku")) == 738594937); - BOOST_CHECK_EQUAL(toml::get(products.at(1).at("name")), + BOOST_TEST(toml::get(products.at(1).at("name")) == "Nail"); - BOOST_CHECK_EQUAL(toml::get(products.at(1).at("sku")), + BOOST_TEST(toml::get(products.at(1).at("sku")) == 284758393); - BOOST_CHECK_EQUAL(toml::get(products.at(1).at("color")), + BOOST_TEST(toml::get(products.at(1).at("color")) == "gray"); } } @@ -409,8 +411,8 @@ BOOST_AUTO_TEST_CASE(test_file_with_BOM) std::istringstream iss(table); const auto data = toml::parse(iss, "test_file_with_BOM.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -425,8 +427,8 @@ BOOST_AUTO_TEST_CASE(test_file_with_BOM) } const auto data = toml::parse("tmp.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -438,8 +440,8 @@ BOOST_AUTO_TEST_CASE(test_file_with_BOM) std::istringstream iss(table); const auto data = toml::parse(iss, "test_file_with_BOM_CRLF.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -457,8 +459,8 @@ BOOST_AUTO_TEST_CASE(test_file_with_BOM) } const auto data = toml::parse("tmp.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(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, "test_file_without_newline_at_the_end_of_file.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { 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, "test_file_without_newline_at_the_end_of_file_CRLF.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(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, "test_file_without_newline_at_the_end_of_file_comment.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { 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, "test_file_without_newline_at_the_end_of_file_comment.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(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, "test_file_without_newline_at_the_end_of_file_ws.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { 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, "test_file_without_newline_at_the_end_of_file_ws.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(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, "test_files_end_with_comment.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -576,8 +578,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_comment) const auto data = toml::parse(iss, "test_files_end_with_comment.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } // comment w/ newline @@ -593,8 +595,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_comment) const auto data = toml::parse(iss, "test_files_end_with_comment.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -608,8 +610,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_comment) const auto data = toml::parse(iss, "test_files_end_with_comment.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } // CRLF version @@ -625,8 +627,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_comment) const auto data = toml::parse(iss, "test_files_end_with_comment.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -640,8 +642,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_comment) const auto data = toml::parse(iss, "test_files_end_with_comment.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -654,8 +656,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_comment) const auto data = toml::parse(iss, "test_files_end_with_comment.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -669,8 +671,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_comment) const auto data = toml::parse(iss, "test_files_end_with_comment.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(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, "test_files_end_with_newline.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -703,8 +705,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines) const auto data = toml::parse(iss, "test_files_end_with_newline.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } // with whitespaces @@ -720,8 +722,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines) const auto data = toml::parse(iss, "test_files_end_with_newline.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -735,8 +737,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines) const auto data = toml::parse(iss, "test_files_end_with_newline.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -750,8 +752,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines) const auto data = toml::parse(iss, "test_files_end_with_newline.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -765,8 +767,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines) const auto data = toml::parse(iss, "test_files_end_with_newline.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } // 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, "test_files_end_with_newline.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(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, "test_files_end_with_newline.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -814,8 +816,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines) const auto data = toml::parse(iss, "test_files_end_with_newline.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } // with whitespaces @@ -831,8 +833,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines) const auto data = toml::parse(iss, "test_files_end_with_newline.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -846,8 +848,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines) const auto data = toml::parse(iss, "test_files_end_with_newline.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -861,8 +863,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines) const auto data = toml::parse(iss, "test_files_end_with_newline.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -876,8 +878,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines) const auto data = toml::parse(iss, "test_files_end_with_newline.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } { const std::string table( @@ -890,8 +892,8 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines) const auto data = toml::parse(iss, "test_files_end_with_newline.toml"); - BOOST_CHECK_EQUAL(toml::find(data, "key"), "value"); - BOOST_CHECK_EQUAL(toml::find(toml::find(data, "table"), "key"), "value"); + BOOST_TEST(toml::find(data, "key") == "value"); + BOOST_TEST(toml::find(toml::find(data, "table"), "key") == "value"); } } diff --git a/tests/test_result.cpp b/tests/test_result.cpp index 4832c5d..d693bd6 100644 --- a/tests/test_result.cpp +++ b/tests/test_result.cpp @@ -8,49 +8,49 @@ BOOST_AUTO_TEST_CASE(test_construct) { auto s = toml::ok(42); toml::result result(s); - BOOST_CHECK(!!result); - BOOST_CHECK(result.is_ok()); - BOOST_CHECK(!result.is_err()); - BOOST_CHECK_EQUAL(result.unwrap(), 42); + BOOST_TEST(!!result); + BOOST_TEST(result.is_ok()); + BOOST_TEST(!result.is_err()); + BOOST_TEST(result.unwrap() == 42); } { const auto s = toml::ok(42); toml::result result(s); - BOOST_CHECK(!!result); - BOOST_CHECK(result.is_ok()); - BOOST_CHECK(!result.is_err()); - BOOST_CHECK_EQUAL(result.unwrap(), 42); + BOOST_TEST(!!result); + BOOST_TEST(result.is_ok()); + BOOST_TEST(!result.is_err()); + BOOST_TEST(result.unwrap() == 42); } { toml::result result(toml::ok(42)); - BOOST_CHECK(!!result); - BOOST_CHECK(result.is_ok()); - BOOST_CHECK(!result.is_err()); - BOOST_CHECK_EQUAL(result.unwrap(), 42); + BOOST_TEST(!!result); + BOOST_TEST(result.is_ok()); + BOOST_TEST(!result.is_err()); + BOOST_TEST(result.unwrap() == 42); } { auto f = toml::err("foobar"); toml::result result(f); - BOOST_CHECK(!result); - BOOST_CHECK(!result.is_ok()); - BOOST_CHECK(result.is_err()); - BOOST_CHECK_EQUAL(result.unwrap_err(), "foobar"); + BOOST_TEST(!result); + BOOST_TEST(!result.is_ok()); + BOOST_TEST(result.is_err()); + BOOST_TEST(result.unwrap_err() == "foobar"); } { const auto f = toml::err("foobar"); toml::result result(f); - BOOST_CHECK(!result); - BOOST_CHECK(!result.is_ok()); - BOOST_CHECK(result.is_err()); - BOOST_CHECK_EQUAL(result.unwrap_err(), "foobar"); + BOOST_TEST(!result); + BOOST_TEST(!result.is_ok()); + BOOST_TEST(result.is_err()); + BOOST_TEST(result.unwrap_err() == "foobar"); } { toml::result result(toml::err("foobar")); - BOOST_CHECK(!result); - BOOST_CHECK(!result.is_ok()); - BOOST_CHECK(result.is_err()); - BOOST_CHECK_EQUAL(result.unwrap_err(), "foobar"); + BOOST_TEST(!result); + BOOST_TEST(!result.is_ok()); + BOOST_TEST(result.is_err()); + BOOST_TEST(result.unwrap_err() == "foobar"); } } @@ -59,54 +59,54 @@ BOOST_AUTO_TEST_CASE(test_assignment) { toml::result result(toml::err("foobar")); result = toml::ok(42); - BOOST_CHECK(!!result); - BOOST_CHECK(result.is_ok()); - BOOST_CHECK(!result.is_err()); - BOOST_CHECK_EQUAL(result.unwrap(), 42); + BOOST_TEST(!!result); + BOOST_TEST(result.is_ok()); + BOOST_TEST(!result.is_err()); + BOOST_TEST(result.unwrap() == 42); } { toml::result result(toml::err("foobar")); auto s = toml::ok(42); result = s; - BOOST_CHECK(!!result); - BOOST_CHECK(result.is_ok()); - BOOST_CHECK(!result.is_err()); - BOOST_CHECK_EQUAL(result.unwrap(), 42); + BOOST_TEST(!!result); + BOOST_TEST(result.is_ok()); + BOOST_TEST(!result.is_err()); + BOOST_TEST(result.unwrap() == 42); } { toml::result result(toml::err("foobar")); const auto s = toml::ok(42); result = s; - BOOST_CHECK(!!result); - BOOST_CHECK(result.is_ok()); - BOOST_CHECK(!result.is_err()); - BOOST_CHECK_EQUAL(result.unwrap(), 42); + BOOST_TEST(!!result); + BOOST_TEST(result.is_ok()); + BOOST_TEST(!result.is_err()); + BOOST_TEST(result.unwrap() == 42); } { toml::result result(toml::err("foobar")); result = toml::err("hoge"); - BOOST_CHECK(!result); - BOOST_CHECK(!result.is_ok()); - BOOST_CHECK(result.is_err()); - BOOST_CHECK_EQUAL(result.unwrap_err(), "hoge"); + BOOST_TEST(!result); + BOOST_TEST(!result.is_ok()); + BOOST_TEST(result.is_err()); + BOOST_TEST(result.unwrap_err() == "hoge"); } { toml::result result(toml::err("foobar")); auto f = toml::err("hoge"); result = f; - BOOST_CHECK(!result); - BOOST_CHECK(!result.is_ok()); - BOOST_CHECK(result.is_err()); - BOOST_CHECK_EQUAL(result.unwrap_err(), "hoge"); + BOOST_TEST(!result); + BOOST_TEST(!result.is_ok()); + BOOST_TEST(result.is_err()); + BOOST_TEST(result.unwrap_err() == "hoge"); } { toml::result result(toml::err("foobar")); const auto f = toml::err("hoge"); result = f; - BOOST_CHECK(!result); - BOOST_CHECK(!result.is_ok()); - BOOST_CHECK(result.is_err()); - BOOST_CHECK_EQUAL(result.unwrap_err(), "hoge"); + BOOST_TEST(!result); + BOOST_TEST(!result.is_ok()); + BOOST_TEST(result.is_err()); + BOOST_TEST(result.unwrap_err() == "hoge"); } } @@ -119,10 +119,10 @@ BOOST_AUTO_TEST_CASE(test_map) return i * 2; }); - BOOST_CHECK(!!mapped); - BOOST_CHECK(mapped.is_ok()); - BOOST_CHECK(!mapped.is_err()); - BOOST_CHECK_EQUAL(mapped.unwrap(), 42 * 2); + BOOST_TEST(!!mapped); + BOOST_TEST(mapped.is_ok()); + BOOST_TEST(!mapped.is_err()); + BOOST_TEST(mapped.unwrap() == 42 * 2); } { toml::result, std::string> @@ -132,10 +132,10 @@ BOOST_AUTO_TEST_CASE(test_map) return *i; }); - BOOST_CHECK(!!mapped); - BOOST_CHECK(mapped.is_ok()); - BOOST_CHECK(!mapped.is_err()); - BOOST_CHECK_EQUAL(mapped.unwrap(), 42); + BOOST_TEST(!!mapped); + BOOST_TEST(mapped.is_ok()); + BOOST_TEST(!mapped.is_err()); + BOOST_TEST(mapped.unwrap() == 42); } { const toml::result result(toml::err("hoge")); @@ -144,10 +144,10 @@ BOOST_AUTO_TEST_CASE(test_map) return i * 2; }); - BOOST_CHECK(!mapped); - BOOST_CHECK(!mapped.is_ok()); - BOOST_CHECK(mapped.is_err()); - BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hoge"); + BOOST_TEST(!mapped); + BOOST_TEST(!mapped.is_ok()); + BOOST_TEST(mapped.is_err()); + BOOST_TEST(mapped.unwrap_err() == "hoge"); } { toml::result, std::string> @@ -157,10 +157,10 @@ BOOST_AUTO_TEST_CASE(test_map) return *i; }); - BOOST_CHECK(!mapped); - BOOST_CHECK(!mapped.is_ok()); - BOOST_CHECK(mapped.is_err()); - BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hoge"); + BOOST_TEST(!mapped); + BOOST_TEST(!mapped.is_ok()); + BOOST_TEST(mapped.is_err()); + BOOST_TEST(mapped.unwrap_err() == "hoge"); } } @@ -173,10 +173,10 @@ BOOST_AUTO_TEST_CASE(test_map_err) return s + s; }); - BOOST_CHECK(!!mapped); - BOOST_CHECK(mapped.is_ok()); - BOOST_CHECK(!mapped.is_err()); - BOOST_CHECK_EQUAL(mapped.unwrap(), 42); + BOOST_TEST(!!mapped); + BOOST_TEST(mapped.is_ok()); + BOOST_TEST(!mapped.is_err()); + BOOST_TEST(mapped.unwrap() == 42); } { toml::result, std::string> @@ -186,10 +186,10 @@ BOOST_AUTO_TEST_CASE(test_map_err) return s + s; }); - BOOST_CHECK(!!mapped); - BOOST_CHECK(mapped.is_ok()); - BOOST_CHECK(!mapped.is_err()); - BOOST_CHECK_EQUAL(*(mapped.unwrap()), 42); + BOOST_TEST(!!mapped); + BOOST_TEST(mapped.is_ok()); + BOOST_TEST(!mapped.is_err()); + BOOST_TEST(*(mapped.unwrap()) == 42); } { const toml::result result(toml::err("hoge")); @@ -197,10 +197,10 @@ BOOST_AUTO_TEST_CASE(test_map_err) [](const std::string s) -> std::string { return s + s; }); - BOOST_CHECK(!mapped); - BOOST_CHECK(!mapped.is_ok()); - BOOST_CHECK(mapped.is_err()); - BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hogehoge"); + BOOST_TEST(!mapped); + BOOST_TEST(!mapped.is_ok()); + BOOST_TEST(mapped.is_err()); + BOOST_TEST(mapped.unwrap_err() == "hogehoge"); } { toml::result> @@ -210,10 +210,10 @@ BOOST_AUTO_TEST_CASE(test_map_err) return *p; }); - BOOST_CHECK(!mapped); - BOOST_CHECK(!mapped.is_ok()); - BOOST_CHECK(mapped.is_err()); - BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hoge"); + BOOST_TEST(!mapped); + BOOST_TEST(!mapped.is_ok()); + BOOST_TEST(mapped.is_err()); + BOOST_TEST(mapped.unwrap_err() == "hoge"); } } @@ -226,7 +226,7 @@ BOOST_AUTO_TEST_CASE(test_map_or_else) return i * 2; }, 54); - BOOST_CHECK_EQUAL(mapped, 42 * 2); + BOOST_TEST(mapped == 42 * 2); } { toml::result, std::string> @@ -236,7 +236,7 @@ BOOST_AUTO_TEST_CASE(test_map_or_else) return *i; }, 54); - BOOST_CHECK_EQUAL(mapped, 42); + BOOST_TEST(mapped == 42); } { const toml::result result(toml::err("hoge")); @@ -245,7 +245,7 @@ BOOST_AUTO_TEST_CASE(test_map_or_else) return i * 2; }, 54); - BOOST_CHECK_EQUAL(mapped, 54); + BOOST_TEST(mapped == 54); } { toml::result, std::string> @@ -255,7 +255,7 @@ BOOST_AUTO_TEST_CASE(test_map_or_else) return *i; }, 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; }, "foobar"); - BOOST_CHECK_EQUAL(mapped, "foobar"); + BOOST_TEST(mapped == "foobar"); } { toml::result, std::string> @@ -278,7 +278,7 @@ BOOST_AUTO_TEST_CASE(test_map_err_or_else) return i + i; }, "foobar"); - BOOST_CHECK_EQUAL(mapped, "foobar"); + BOOST_TEST(mapped == "foobar"); } { const toml::result result(toml::err("hoge")); @@ -287,7 +287,7 @@ BOOST_AUTO_TEST_CASE(test_map_err_or_else) return i + i; }, "foobar"); - BOOST_CHECK_EQUAL(mapped, "hogehoge"); + BOOST_TEST(mapped == "hogehoge"); } { toml::result, std::string> @@ -297,7 +297,7 @@ BOOST_AUTO_TEST_CASE(test_map_err_or_else) return i + i; }, "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); }); - BOOST_CHECK(!!mapped); - BOOST_CHECK(mapped.is_ok()); - BOOST_CHECK(!mapped.is_err()); - BOOST_CHECK_EQUAL(mapped.unwrap(), 42 * 2); + BOOST_TEST(!!mapped); + BOOST_TEST(mapped.is_ok()); + BOOST_TEST(!mapped.is_err()); + BOOST_TEST(mapped.unwrap() == 42 * 2); } { toml::result, std::string> @@ -324,10 +324,10 @@ BOOST_AUTO_TEST_CASE(test_and_then) return toml::ok(*i); }); - BOOST_CHECK(!!mapped); - BOOST_CHECK(mapped.is_ok()); - BOOST_CHECK(!mapped.is_err()); - BOOST_CHECK_EQUAL(mapped.unwrap(), 42); + BOOST_TEST(!!mapped); + BOOST_TEST(mapped.is_ok()); + BOOST_TEST(!mapped.is_err()); + BOOST_TEST(mapped.unwrap() == 42); } { const toml::result result(toml::err("hoge")); @@ -336,10 +336,10 @@ BOOST_AUTO_TEST_CASE(test_and_then) return toml::ok(i * 2); }); - BOOST_CHECK(!mapped); - BOOST_CHECK(!mapped.is_ok()); - BOOST_CHECK(mapped.is_err()); - BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hoge"); + BOOST_TEST(!mapped); + BOOST_TEST(!mapped.is_ok()); + BOOST_TEST(mapped.is_err()); + BOOST_TEST(mapped.unwrap_err() == "hoge"); } { toml::result, std::string> @@ -349,10 +349,10 @@ BOOST_AUTO_TEST_CASE(test_and_then) return toml::ok(*i); }); - BOOST_CHECK(!mapped); - BOOST_CHECK(!mapped.is_ok()); - BOOST_CHECK(mapped.is_err()); - BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hoge"); + BOOST_TEST(!mapped); + BOOST_TEST(!mapped.is_ok()); + BOOST_TEST(mapped.is_err()); + BOOST_TEST(mapped.unwrap_err() == "hoge"); } } @@ -365,10 +365,10 @@ BOOST_AUTO_TEST_CASE(test_or_else) return toml::err(s + s); }); - BOOST_CHECK(!!mapped); - BOOST_CHECK(mapped.is_ok()); - BOOST_CHECK(!mapped.is_err()); - BOOST_CHECK_EQUAL(mapped.unwrap(), 42); + BOOST_TEST(!!mapped); + BOOST_TEST(mapped.is_ok()); + BOOST_TEST(!mapped.is_err()); + BOOST_TEST(mapped.unwrap() == 42); } { toml::result, std::string> @@ -378,10 +378,10 @@ BOOST_AUTO_TEST_CASE(test_or_else) return toml::err(s + s); }); - BOOST_CHECK(!!mapped); - BOOST_CHECK(mapped.is_ok()); - BOOST_CHECK(!mapped.is_err()); - BOOST_CHECK_EQUAL(*mapped.unwrap(), 42); + BOOST_TEST(!!mapped); + BOOST_TEST(mapped.is_ok()); + BOOST_TEST(!mapped.is_err()); + BOOST_TEST(*mapped.unwrap() == 42); } { const toml::result result(toml::err("hoge")); @@ -390,10 +390,10 @@ BOOST_AUTO_TEST_CASE(test_or_else) return toml::err(s + s); }); - BOOST_CHECK(!mapped); - BOOST_CHECK(!mapped.is_ok()); - BOOST_CHECK(mapped.is_err()); - BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hogehoge"); + BOOST_TEST(!mapped); + BOOST_TEST(!mapped.is_ok()); + BOOST_TEST(mapped.is_err()); + BOOST_TEST(mapped.unwrap_err() == "hogehoge"); } { toml::result, std::string> @@ -403,10 +403,10 @@ BOOST_AUTO_TEST_CASE(test_or_else) return toml::err(s + s); }); - BOOST_CHECK(!mapped); - BOOST_CHECK(!mapped.is_ok()); - BOOST_CHECK(mapped.is_err()); - BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hogehoge"); + BOOST_TEST(!mapped); + BOOST_TEST(!mapped.is_ok()); + BOOST_TEST(mapped.is_err()); + BOOST_TEST(mapped.unwrap_err() == "hogehoge"); } } @@ -416,10 +416,10 @@ BOOST_AUTO_TEST_CASE(test_and_or_other) const toml::result r1(toml::ok(42)); const toml::result r2(toml::err("foo")); - BOOST_CHECK_EQUAL(r1, r1.or_other(r2)); - BOOST_CHECK_EQUAL(r2, r1.and_other(r2)); - BOOST_CHECK_EQUAL(42, r1.or_other(r2).unwrap()); - BOOST_CHECK_EQUAL("foo", r1.and_other(r2).unwrap_err()); + BOOST_TEST(r1 == r1.or_other(r2)); + BOOST_TEST(r2 == r1.and_other(r2)); + BOOST_TEST(42 == r1.or_other(r2).unwrap()); + BOOST_TEST("foo" == r1.and_other(r2).unwrap_err()); } { auto r1_gen = []() -> toml::result { @@ -431,10 +431,10 @@ BOOST_AUTO_TEST_CASE(test_and_or_other) const auto r3 = r1_gen(); const auto r4 = r2_gen(); - BOOST_CHECK_EQUAL(r3, r1_gen().or_other (r2_gen())); - BOOST_CHECK_EQUAL(r4, r1_gen().and_other(r2_gen())); - BOOST_CHECK_EQUAL(42, r1_gen().or_other (r2_gen()).unwrap()); - BOOST_CHECK_EQUAL("foo", r1_gen().and_other(r2_gen()).unwrap_err()); + BOOST_TEST(r3 == r1_gen().or_other (r2_gen())); + BOOST_TEST(r4 == r1_gen().and_other(r2_gen())); + BOOST_TEST(42 == r1_gen().or_other (r2_gen()).unwrap()); + BOOST_TEST("foo" == r1_gen().and_other(r2_gen()).unwrap_err()); } } diff --git a/tests/test_serialize_file.cpp b/tests/test_serialize_file.cpp index 372249b..5c963b8 100644 --- a/tests/test_serialize_file.cpp +++ b/tests/test_serialize_file.cpp @@ -19,15 +19,38 @@ BOOST_AUTO_TEST_CASE(test_example) auto serialized = toml::parse("tmp1.toml"); { - auto& owner = toml::find(serialized, "owner"); - auto& bio = toml::get(owner.at("bio")); + auto& owner = toml::find(serialized, "owner"); + auto& bio = toml::find(owner, "bio"); const auto CR = std::find(bio.begin(), bio.end(), '\r'); if(CR != bio.end()) { 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/tests/example.toml"); + { + std::ofstream ofs("tmp1.toml"); + ofs << std::setw(80) << data; + } + + auto serialized = toml::parse( + "tmp1.toml"); + { + auto& owner = toml::find(serialized, "owner"); + auto& bio = toml::find(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) @@ -40,15 +63,42 @@ BOOST_AUTO_TEST_CASE(test_example_with_comment) auto serialized = toml::parse("tmp1_com.toml"); { - auto& owner = toml::find(serialized, "owner"); - auto& bio = toml::get(owner.at("bio")); + auto& owner = toml::find(serialized, "owner"); + auto& bio = toml::find(owner, "bio"); const auto CR = std::find(bio.begin(), bio.end(), '\r'); if(CR != bio.end()) { 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/tests/example.toml"); + { + std::ofstream ofs("tmp1_com.toml"); + ofs << std::setw(80) << data; + } + + auto serialized = toml::parse( + "tmp1_com.toml"); + { + auto& owner = toml::find(serialized, "owner"); + auto& bio = toml::find(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"); ofs << std::setw(80) << serialized; @@ -63,7 +113,20 @@ BOOST_AUTO_TEST_CASE(test_fruit) ofs << std::setw(80) << data; } 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/tests/fruit.toml"); + { + std::ofstream ofs("tmp2.toml"); + ofs << std::setw(80) << data; + } + const auto serialized = toml::parse( + "tmp2.toml"); + BOOST_TEST(data == serialized); } 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; } const auto serialized = toml::parse("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/tests/fruit.toml"); + { + std::ofstream ofs("tmp2_com.toml"); + ofs << std::setw(80) << data; + } + const auto serialized = toml::parse("tmp2_com.toml"); + BOOST_TEST(data == serialized); } BOOST_AUTO_TEST_CASE(test_hard_example) @@ -85,20 +160,35 @@ BOOST_AUTO_TEST_CASE(test_hard_example) ofs << std::setw(80) << data; } 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/tests/hard_example.toml"); + { + std::ofstream ofs("tmp3.toml"); + ofs << std::setw(80) << data; + } + const auto serialized = toml::parse( + "tmp3.toml"); + BOOST_TEST(data == serialized); } BOOST_AUTO_TEST_CASE(test_hard_example_with_comment) { - const auto data = toml::parse("toml/tests/hard_example.toml"); + const auto data = toml::parse( + "toml/tests/hard_example.toml"); { std::ofstream ofs("tmp3_com.toml"); ofs << std::setw(80) << data; } - const auto serialized = toml::parse("tmp3_com.toml"); + const auto serialized = toml::parse( + "tmp3_com.toml"); { std::ofstream ofs("tmp3_com1.toml"); ofs << std::setw(80) << serialized; } - BOOST_CHECK(data == serialized); + BOOST_TEST(data == serialized); } diff --git a/tests/test_value.cpp b/tests/test_value.cpp index ee0f003..a0d32c6 100644 --- a/tests/test_value.cpp +++ b/tests/test_value.cpp @@ -5,7 +5,7 @@ #define BOOST_TEST_NO_LIB #include #endif -#include +#include #include #include @@ -19,91 +19,91 @@ BOOST_AUTO_TEST_CASE(test_value_boolean) toml::value v1(true); toml::value v2(false); - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::boolean); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::boolean); - BOOST_CHECK(v1.is(toml::value_t::boolean)); - BOOST_CHECK(v2.is(toml::value_t::boolean)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v1.is_boolean()); - BOOST_CHECK(v2.is_boolean()); + BOOST_TEST(v1.type() == toml::value_t::boolean); + BOOST_TEST(v2.type() == toml::value_t::boolean); + BOOST_TEST(v1.is(toml::value_t::boolean)); + BOOST_TEST(v2.is(toml::value_t::boolean)); + BOOST_TEST(v1.is()); + BOOST_TEST(v2.is()); + BOOST_TEST(v1.is_boolean()); + BOOST_TEST(v2.is_boolean()); - BOOST_CHECK_EQUAL(v1.cast(), true); - BOOST_CHECK_EQUAL(v2.cast(), false); - BOOST_CHECK_EQUAL(v1.as_boolean(), true); - BOOST_CHECK_EQUAL(v2.as_boolean(), false); - BOOST_CHECK_EQUAL(v1.as_boolean(std::nothrow), true); - BOOST_CHECK_EQUAL(v2.as_boolean(std::nothrow), false); + BOOST_TEST(v1.cast() == true); + BOOST_TEST(v2.cast() == false); + BOOST_TEST(v1.as_boolean() == true); + BOOST_TEST(v2.as_boolean() == false); + BOOST_TEST(v1.as_boolean(std::nothrow) == true); + BOOST_TEST(v2.as_boolean(std::nothrow) == false); v1 = false; v2 = true; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::boolean); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::boolean); - BOOST_CHECK(v1.is(toml::value_t::boolean)); - BOOST_CHECK(v2.is(toml::value_t::boolean)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v1.is_boolean()); - BOOST_CHECK(v2.is_boolean()); + BOOST_TEST(v1.type() == toml::value_t::boolean); + BOOST_TEST(v2.type() == toml::value_t::boolean); + BOOST_TEST(v1.is(toml::value_t::boolean)); + BOOST_TEST(v2.is(toml::value_t::boolean)); + BOOST_TEST(v1.is()); + BOOST_TEST(v2.is()); + BOOST_TEST(v1.is_boolean()); + BOOST_TEST(v2.is_boolean()); - BOOST_CHECK_EQUAL(v1.cast(), false); - BOOST_CHECK_EQUAL(v2.cast(), true); - BOOST_CHECK_EQUAL(v1.as_boolean(), false); - BOOST_CHECK_EQUAL(v2.as_boolean(), true); + BOOST_TEST(v1.cast() == false); + BOOST_TEST(v2.cast() == true); + BOOST_TEST(v1.as_boolean() == false); + BOOST_TEST(v2.as_boolean() == true); toml::value v3(v1); toml::value v4(v2); - BOOST_CHECK(v3 == v1); - BOOST_CHECK(v4 == v2); + BOOST_TEST(v3 == v1); + BOOST_TEST(v4 == v2); - BOOST_CHECK_EQUAL(v3.type(), toml::value_t::boolean); - BOOST_CHECK_EQUAL(v4.type(), toml::value_t::boolean); - BOOST_CHECK(v3.is(toml::value_t::boolean)); - BOOST_CHECK(v4.is(toml::value_t::boolean)); - BOOST_CHECK(v3.is()); - BOOST_CHECK(v4.is()); - BOOST_CHECK(v3.is_boolean()); - BOOST_CHECK(v4.is_boolean()); + BOOST_TEST(v3.type() == toml::value_t::boolean); + BOOST_TEST(v4.type() == toml::value_t::boolean); + BOOST_TEST(v3.is(toml::value_t::boolean)); + BOOST_TEST(v4.is(toml::value_t::boolean)); + BOOST_TEST(v3.is()); + BOOST_TEST(v4.is()); + BOOST_TEST(v3.is_boolean()); + BOOST_TEST(v4.is_boolean()); - BOOST_CHECK_EQUAL(v3.cast(), false); - BOOST_CHECK_EQUAL(v4.cast(), true); - BOOST_CHECK_EQUAL(v3.as_boolean(), false); - BOOST_CHECK_EQUAL(v4.as_boolean(), true); + BOOST_TEST(v3.cast() == false); + BOOST_TEST(v4.cast() == true); + BOOST_TEST(v3.as_boolean() == false); + BOOST_TEST(v4.as_boolean() == true); toml::value v5(std::move(v1)); toml::value v6(std::move(v2)); - BOOST_CHECK_EQUAL(v5.type(), toml::value_t::boolean); - BOOST_CHECK_EQUAL(v6.type(), toml::value_t::boolean); - BOOST_CHECK(v5.is(toml::value_t::boolean)); - BOOST_CHECK(v6.is(toml::value_t::boolean)); - BOOST_CHECK(v5.is()); - BOOST_CHECK(v6.is()); - BOOST_CHECK(v3.is_boolean()); - BOOST_CHECK(v4.is_boolean()); + BOOST_TEST(v5.type() == toml::value_t::boolean); + BOOST_TEST(v6.type() == toml::value_t::boolean); + BOOST_TEST(v5.is(toml::value_t::boolean)); + BOOST_TEST(v6.is(toml::value_t::boolean)); + BOOST_TEST(v5.is()); + BOOST_TEST(v6.is()); + BOOST_TEST(v3.is_boolean()); + BOOST_TEST(v4.is_boolean()); - BOOST_CHECK_EQUAL(v5.cast(), false); - BOOST_CHECK_EQUAL(v6.cast(), true); - BOOST_CHECK_EQUAL(v5.as_boolean(), false); - BOOST_CHECK_EQUAL(v6.as_boolean(), true); + BOOST_TEST(v5.cast() == false); + BOOST_TEST(v6.cast() == true); + BOOST_TEST(v5.as_boolean() == false); + BOOST_TEST(v6.as_boolean() == true); v1 = 42; v2 = 3.14; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::integer); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::floating); - BOOST_CHECK(v1.is(toml::value_t::integer)); - BOOST_CHECK(v2.is(toml::value_t::floating)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v1.is_integer()); - BOOST_CHECK(v2.is_floating()); + BOOST_TEST(v1.type() == toml::value_t::integer); + BOOST_TEST(v2.type() == toml::value_t::floating); + BOOST_TEST(v1.is(toml::value_t::integer)); + BOOST_TEST(v2.is(toml::value_t::floating)); + BOOST_TEST(v1.is()); + BOOST_TEST(v2.is()); + BOOST_TEST(v1.is_integer()); + BOOST_TEST(v2.is_floating()); - BOOST_CHECK_EQUAL(v1.cast(), 42); - BOOST_CHECK_EQUAL(v2.cast(), 3.14); - BOOST_CHECK_EQUAL(v1.as_integer(), 42); - BOOST_CHECK_EQUAL(v2.as_floating(), 3.14); + BOOST_TEST(v1.cast() == 42); + BOOST_TEST(v2.cast() == 3.14); + BOOST_TEST(v1.as_integer() == 42); + BOOST_TEST(v2.as_floating() == 3.14); } BOOST_AUTO_TEST_CASE(test_value_integer) @@ -111,91 +111,91 @@ BOOST_AUTO_TEST_CASE(test_value_integer) toml::value v1(-42); toml::value v2(42u); - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::integer); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::integer); - BOOST_CHECK(v1.is(toml::value_t::integer)); - BOOST_CHECK(v2.is(toml::value_t::integer)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v1.is_integer()); - BOOST_CHECK(v2.is_integer()); + BOOST_TEST(v1.type() == toml::value_t::integer); + BOOST_TEST(v2.type() == toml::value_t::integer); + BOOST_TEST(v1.is(toml::value_t::integer)); + BOOST_TEST(v2.is(toml::value_t::integer)); + BOOST_TEST(v1.is()); + BOOST_TEST(v2.is()); + BOOST_TEST(v1.is_integer()); + BOOST_TEST(v2.is_integer()); - BOOST_CHECK_EQUAL(v1.cast(), -42); - BOOST_CHECK_EQUAL(v2.cast(), 42u); - BOOST_CHECK_EQUAL(v1.as_integer(), -42); - BOOST_CHECK_EQUAL(v2.as_integer(), 42u); - BOOST_CHECK_EQUAL(v1.as_integer(std::nothrow), -42); - BOOST_CHECK_EQUAL(v2.as_integer(std::nothrow), 42u); + BOOST_TEST(v1.cast() == -42); + BOOST_TEST(v2.cast() == 42u); + BOOST_TEST(v1.as_integer() == -42); + BOOST_TEST(v2.as_integer() == 42u); + BOOST_TEST(v1.as_integer(std::nothrow) == -42); + BOOST_TEST(v2.as_integer(std::nothrow) == 42u); v1 = 54; v2 = -54; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::integer); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::integer); - BOOST_CHECK(v1.is(toml::value_t::integer)); - BOOST_CHECK(v2.is(toml::value_t::integer)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v1.is_integer()); - BOOST_CHECK(v2.is_integer()); + BOOST_TEST(v1.type() == toml::value_t::integer); + BOOST_TEST(v2.type() == toml::value_t::integer); + BOOST_TEST(v1.is(toml::value_t::integer)); + BOOST_TEST(v2.is(toml::value_t::integer)); + BOOST_TEST(v1.is()); + BOOST_TEST(v2.is()); + BOOST_TEST(v1.is_integer()); + BOOST_TEST(v2.is_integer()); - BOOST_CHECK_EQUAL(v1.cast(), 54); - BOOST_CHECK_EQUAL(v2.cast(), -54); - BOOST_CHECK_EQUAL(v1.as_integer(), 54); - BOOST_CHECK_EQUAL(v2.as_integer(), -54); + BOOST_TEST(v1.cast() == 54); + BOOST_TEST(v2.cast() == -54); + BOOST_TEST(v1.as_integer() == 54); + BOOST_TEST(v2.as_integer() == -54); toml::value v3(v1); toml::value v4(v2); - BOOST_CHECK(v3 == v1); - BOOST_CHECK(v4 == v2); + BOOST_TEST(v3 == v1); + BOOST_TEST(v4 == v2); - BOOST_CHECK_EQUAL(v3.type(), toml::value_t::integer); - BOOST_CHECK_EQUAL(v4.type(), toml::value_t::integer); - BOOST_CHECK(v3.is(toml::value_t::integer)); - BOOST_CHECK(v4.is(toml::value_t::integer)); - BOOST_CHECK(v3.is()); - BOOST_CHECK(v4.is()); - BOOST_CHECK(v3.is_integer()); - BOOST_CHECK(v4.is_integer()); + BOOST_TEST(v3.type() == toml::value_t::integer); + BOOST_TEST(v4.type() == toml::value_t::integer); + BOOST_TEST(v3.is(toml::value_t::integer)); + BOOST_TEST(v4.is(toml::value_t::integer)); + BOOST_TEST(v3.is()); + BOOST_TEST(v4.is()); + BOOST_TEST(v3.is_integer()); + BOOST_TEST(v4.is_integer()); - BOOST_CHECK_EQUAL(v3.cast(), 54); - BOOST_CHECK_EQUAL(v4.cast(), -54); - BOOST_CHECK_EQUAL(v3.as_integer(), 54); - BOOST_CHECK_EQUAL(v4.as_integer(), -54); + BOOST_TEST(v3.cast() == 54); + BOOST_TEST(v4.cast() == -54); + BOOST_TEST(v3.as_integer() == 54); + BOOST_TEST(v4.as_integer() == -54); toml::value v5(std::move(v1)); toml::value v6(std::move(v2)); - BOOST_CHECK_EQUAL(v5.type(), toml::value_t::integer); - BOOST_CHECK_EQUAL(v6.type(), toml::value_t::integer); - BOOST_CHECK(v5.is(toml::value_t::integer)); - BOOST_CHECK(v6.is(toml::value_t::integer)); - BOOST_CHECK(v5.is()); - BOOST_CHECK(v6.is()); - BOOST_CHECK(v5.is_integer()); - BOOST_CHECK(v6.is_integer()); + BOOST_TEST(v5.type() == toml::value_t::integer); + BOOST_TEST(v6.type() == toml::value_t::integer); + BOOST_TEST(v5.is(toml::value_t::integer)); + BOOST_TEST(v6.is(toml::value_t::integer)); + BOOST_TEST(v5.is()); + BOOST_TEST(v6.is()); + BOOST_TEST(v5.is_integer()); + BOOST_TEST(v6.is_integer()); - BOOST_CHECK_EQUAL(v5.cast(), 54); - BOOST_CHECK_EQUAL(v6.cast(), -54); - BOOST_CHECK_EQUAL(v5.as_integer(), 54); - BOOST_CHECK_EQUAL(v6.as_integer(), -54); + BOOST_TEST(v5.cast() == 54); + BOOST_TEST(v6.cast() == -54); + BOOST_TEST(v5.as_integer() == 54); + BOOST_TEST(v6.as_integer() == -54); v1 = true; v2 = false; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::boolean); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::boolean); - BOOST_CHECK(v1.is(toml::value_t::boolean)); - BOOST_CHECK(v2.is(toml::value_t::boolean)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v1.is_boolean()); - BOOST_CHECK(v2.is_boolean()); + BOOST_TEST(v1.type() == toml::value_t::boolean); + BOOST_TEST(v2.type() == toml::value_t::boolean); + BOOST_TEST(v1.is(toml::value_t::boolean)); + BOOST_TEST(v2.is(toml::value_t::boolean)); + BOOST_TEST(v1.is()); + BOOST_TEST(v2.is()); + BOOST_TEST(v1.is_boolean()); + BOOST_TEST(v2.is_boolean()); - BOOST_CHECK_EQUAL(v1.cast(), true); - BOOST_CHECK_EQUAL(v2.cast(), false); - BOOST_CHECK_EQUAL(v1.as_boolean(), true); - BOOST_CHECK_EQUAL(v2.as_boolean(), false); + BOOST_TEST(v1.cast() == true); + BOOST_TEST(v2.cast() == false); + BOOST_TEST(v1.as_boolean() == true); + BOOST_TEST(v2.as_boolean() == false); } BOOST_AUTO_TEST_CASE(test_value_float) @@ -203,91 +203,100 @@ BOOST_AUTO_TEST_CASE(test_value_float) toml::value v1(3.14); toml::value v2(3.14f); - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::floating); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::floating); - BOOST_CHECK(v1.is(toml::value_t::floating)); - BOOST_CHECK(v2.is(toml::value_t::floating)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v1.is_floating()); - BOOST_CHECK(v2.is_floating()); + BOOST_TEST(v1.type() == toml::value_t::floating); + BOOST_TEST(v2.type() == toml::value_t::floating); + BOOST_TEST(v1.is(toml::value_t::floating)); + BOOST_TEST(v2.is(toml::value_t::floating)); + BOOST_TEST(v1.is()); + BOOST_TEST(v2.is()); + BOOST_TEST(v1.is_floating()); + BOOST_TEST(v2.is_floating()); - BOOST_CHECK_EQUAL (v1.cast(), 3.14); - BOOST_CHECK_CLOSE_FRACTION(v2.cast(), 3.14, 1e-2); - BOOST_CHECK_EQUAL (v1.as_floating(), 3.14); - BOOST_CHECK_CLOSE_FRACTION(v2.as_floating(), 3.14, 1e-2); - BOOST_CHECK_EQUAL (v1.as_floating(std::nothrow), 3.14); - BOOST_CHECK_CLOSE_FRACTION(v2.as_floating(std::nothrow), 3.14, 1e-2); + BOOST_TEST(v1.cast() == 3.14); + BOOST_TEST(v2.cast() == 3.14, + boost::test_tools::tolerance(1e-2)); + BOOST_TEST(v1.as_floating() == 3.14); + BOOST_TEST(v2.as_floating() == 3.14, + boost::test_tools::tolerance(1e-2)); + BOOST_TEST(v1.as_floating(std::nothrow) == 3.14); + BOOST_TEST(v2.as_floating(std::nothrow) == 3.14, + boost::test_tools::tolerance(1e-2)); v1 = 2.718f; v2 = 2.718; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::floating); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::floating); - BOOST_CHECK(v1.is(toml::value_t::floating)); - BOOST_CHECK(v2.is(toml::value_t::floating)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v1.is_floating()); - BOOST_CHECK(v2.is_floating()); + BOOST_TEST(v1.type() == toml::value_t::floating); + BOOST_TEST(v2.type() == toml::value_t::floating); + BOOST_TEST(v1.is(toml::value_t::floating)); + BOOST_TEST(v2.is(toml::value_t::floating)); + BOOST_TEST(v1.is()); + BOOST_TEST(v2.is()); + BOOST_TEST(v1.is_floating()); + BOOST_TEST(v2.is_floating()); - BOOST_CHECK_CLOSE_FRACTION(v1.cast(), 2.718, 1e-3); - BOOST_CHECK_EQUAL (v2.cast(), 2.718); - BOOST_CHECK_CLOSE_FRACTION(v1.as_floating(), 2.718, 1e-3); - BOOST_CHECK_EQUAL (v2.as_floating(), 2.718); + BOOST_TEST(v1.cast() == 2.718, + boost::test_tools::tolerance(1e-3)); + BOOST_TEST(v2.cast() == 2.718); + BOOST_TEST(v1.as_floating() == 2.718, + boost::test_tools::tolerance(1e-3)); + BOOST_TEST(v2.as_floating() == 2.718); toml::value v3(v1); toml::value v4(v2); - BOOST_CHECK(v3 == v1); - BOOST_CHECK(v4 == v2); + BOOST_TEST(v3 == v1); + BOOST_TEST(v4 == v2); - BOOST_CHECK_EQUAL(v3.type(), toml::value_t::floating); - BOOST_CHECK_EQUAL(v4.type(), toml::value_t::floating); - BOOST_CHECK(v3.is(toml::value_t::floating)); - BOOST_CHECK(v4.is(toml::value_t::floating)); - BOOST_CHECK(v3.is()); - BOOST_CHECK(v4.is()); - BOOST_CHECK(v3.is_floating()); - BOOST_CHECK(v4.is_floating()); + BOOST_TEST(v3.type() == toml::value_t::floating); + BOOST_TEST(v4.type() == toml::value_t::floating); + BOOST_TEST(v3.is(toml::value_t::floating)); + BOOST_TEST(v4.is(toml::value_t::floating)); + BOOST_TEST(v3.is()); + BOOST_TEST(v4.is()); + BOOST_TEST(v3.is_floating()); + BOOST_TEST(v4.is_floating()); - BOOST_CHECK_CLOSE_FRACTION(v3.cast(), 2.718, 1e-3); - BOOST_CHECK_EQUAL (v4.cast(), 2.718); - BOOST_CHECK_CLOSE_FRACTION(v3.as_floating(), 2.718, 1e-3); - BOOST_CHECK_EQUAL (v4.as_floating(), 2.718); + BOOST_TEST(v3.cast() == 2.718, + boost::test_tools::tolerance(1e-3)); + BOOST_TEST(v4.cast() == 2.718); + BOOST_TEST(v3.as_floating() == 2.718, + boost::test_tools::tolerance(1e-3)); + BOOST_TEST(v4.as_floating() == 2.718); toml::value v5(std::move(v1)); toml::value v6(std::move(v2)); - BOOST_CHECK_EQUAL(v5.type(), toml::value_t::floating); - BOOST_CHECK_EQUAL(v6.type(), toml::value_t::floating); - BOOST_CHECK(v5.is(toml::value_t::floating)); - BOOST_CHECK(v6.is(toml::value_t::floating)); - BOOST_CHECK(v5.is()); - BOOST_CHECK(v6.is()); - BOOST_CHECK(v5.is_floating()); - BOOST_CHECK(v6.is_floating()); + BOOST_TEST(v5.type() == toml::value_t::floating); + BOOST_TEST(v6.type() == toml::value_t::floating); + BOOST_TEST(v5.is(toml::value_t::floating)); + BOOST_TEST(v6.is(toml::value_t::floating)); + BOOST_TEST(v5.is()); + BOOST_TEST(v6.is()); + BOOST_TEST(v5.is_floating()); + BOOST_TEST(v6.is_floating()); - BOOST_CHECK_CLOSE_FRACTION(v5.cast(), 2.718, 1e-3); - BOOST_CHECK_EQUAL (v6.cast(), 2.718); - BOOST_CHECK_CLOSE_FRACTION(v5.as_floating(), 2.718, 1e-3); - BOOST_CHECK_EQUAL (v6.as_floating(), 2.718); + BOOST_TEST(v5.cast() == 2.718, + boost::test_tools::tolerance(1e-3)); + BOOST_TEST(v6.cast() == 2.718); + BOOST_TEST(v5.as_floating() == 2.718, + boost::test_tools::tolerance(1e-3)); + BOOST_TEST(v6.as_floating() == 2.718); v1 = true; v2 = false; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::boolean); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::boolean); - BOOST_CHECK(v1.is(toml::value_t::boolean)); - BOOST_CHECK(v2.is(toml::value_t::boolean)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v1.is_boolean()); - BOOST_CHECK(v2.is_boolean()); + BOOST_TEST(v1.type() == toml::value_t::boolean); + BOOST_TEST(v2.type() == toml::value_t::boolean); + BOOST_TEST(v1.is(toml::value_t::boolean)); + BOOST_TEST(v2.is(toml::value_t::boolean)); + BOOST_TEST(v1.is()); + BOOST_TEST(v2.is()); + BOOST_TEST(v1.is_boolean()); + BOOST_TEST(v2.is_boolean()); - BOOST_CHECK_EQUAL(v1.cast(), true); - BOOST_CHECK_EQUAL(v2.cast(), false); - BOOST_CHECK_EQUAL(v1.as_boolean(), true); - BOOST_CHECK_EQUAL(v2.as_boolean(), false); + BOOST_TEST(v1.cast() == true); + BOOST_TEST(v2.cast() == false); + BOOST_TEST(v1.as_boolean() == true); + BOOST_TEST(v2.as_boolean() == false); } BOOST_AUTO_TEST_CASE(test_value_string) @@ -296,123 +305,123 @@ BOOST_AUTO_TEST_CASE(test_value_string) toml::value v2(std::string("foo"), toml::string_t::literal); toml::value v3("foo"); - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::string); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::string); - BOOST_CHECK_EQUAL(v3.type(), toml::value_t::string); - BOOST_CHECK(v1.is(toml::value_t::string)); - BOOST_CHECK(v2.is(toml::value_t::string)); - BOOST_CHECK(v3.is(toml::value_t::string)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v3.is()); - BOOST_CHECK(v1.is_string()); - BOOST_CHECK(v2.is_string()); - BOOST_CHECK(v3.is_string()); + BOOST_TEST(v1.type() == toml::value_t::string); + BOOST_TEST(v2.type() == toml::value_t::string); + BOOST_TEST(v3.type() == toml::value_t::string); + BOOST_TEST(v1.is(toml::value_t::string)); + BOOST_TEST(v2.is(toml::value_t::string)); + BOOST_TEST(v3.is(toml::value_t::string)); + BOOST_TEST(v1.is()); + BOOST_TEST(v2.is()); + BOOST_TEST(v3.is()); + BOOST_TEST(v1.is_string()); + BOOST_TEST(v2.is_string()); + BOOST_TEST(v3.is_string()); - BOOST_CHECK_EQUAL(v1.cast(), "foo"); - BOOST_CHECK_EQUAL(v2.cast(), "foo"); - BOOST_CHECK_EQUAL(v3.cast(), "foo"); - BOOST_CHECK_EQUAL(v1.as_string(), "foo"); - BOOST_CHECK_EQUAL(v2.as_string(), "foo"); - BOOST_CHECK_EQUAL(v3.as_string(), "foo"); - BOOST_CHECK_EQUAL(v1.as_string(std::nothrow), "foo"); - BOOST_CHECK_EQUAL(v2.as_string(std::nothrow), "foo"); - BOOST_CHECK_EQUAL(v3.as_string(std::nothrow), "foo"); + BOOST_TEST(v1.cast() == "foo"); + BOOST_TEST(v2.cast() == "foo"); + BOOST_TEST(v3.cast() == "foo"); + BOOST_TEST(v1.as_string() == "foo"); + BOOST_TEST(v2.as_string() == "foo"); + BOOST_TEST(v3.as_string() == "foo"); + BOOST_TEST(v1.as_string(std::nothrow) == "foo"); + BOOST_TEST(v2.as_string(std::nothrow) == "foo"); + BOOST_TEST(v3.as_string(std::nothrow) == "foo"); v1 = "bar"; v2 = "bar"; v3 = "bar"; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::string); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::string); - BOOST_CHECK_EQUAL(v3.type(), toml::value_t::string); - BOOST_CHECK(v1.is(toml::value_t::string)); - BOOST_CHECK(v2.is(toml::value_t::string)); - BOOST_CHECK(v3.is(toml::value_t::string)); - BOOST_CHECK(v1.is_string()); - BOOST_CHECK(v2.is_string()); - BOOST_CHECK(v3.is_string()); + BOOST_TEST(v1.type() == toml::value_t::string); + BOOST_TEST(v2.type() == toml::value_t::string); + BOOST_TEST(v3.type() == toml::value_t::string); + BOOST_TEST(v1.is(toml::value_t::string)); + BOOST_TEST(v2.is(toml::value_t::string)); + BOOST_TEST(v3.is(toml::value_t::string)); + BOOST_TEST(v1.is_string()); + BOOST_TEST(v2.is_string()); + BOOST_TEST(v3.is_string()); - BOOST_CHECK_EQUAL(v1.cast(), "bar"); - BOOST_CHECK_EQUAL(v2.cast(), "bar"); - BOOST_CHECK_EQUAL(v3.cast(), "bar"); - BOOST_CHECK_EQUAL(v1.as_string(), "bar"); - BOOST_CHECK_EQUAL(v2.as_string(), "bar"); - BOOST_CHECK_EQUAL(v3.as_string(), "bar"); + BOOST_TEST(v1.cast() == "bar"); + BOOST_TEST(v2.cast() == "bar"); + BOOST_TEST(v3.cast() == "bar"); + BOOST_TEST(v1.as_string() == "bar"); + BOOST_TEST(v2.as_string() == "bar"); + BOOST_TEST(v3.as_string() == "bar"); toml::value v4(v1); toml::value v5(v2); toml::value v6(v3); - BOOST_CHECK(v4 == v1); - BOOST_CHECK(v5 == v2); - BOOST_CHECK(v6 == v3); + BOOST_TEST(v4 == v1); + BOOST_TEST(v5 == v2); + BOOST_TEST(v6 == v3); - BOOST_CHECK_EQUAL(v4.type(), toml::value_t::string); - BOOST_CHECK_EQUAL(v5.type(), toml::value_t::string); - BOOST_CHECK_EQUAL(v6.type(), toml::value_t::string); - BOOST_CHECK(v4.is(toml::value_t::string)); - BOOST_CHECK(v5.is(toml::value_t::string)); - BOOST_CHECK(v6.is(toml::value_t::string)); - BOOST_CHECK(v4.is()); - BOOST_CHECK(v5.is()); - BOOST_CHECK(v6.is()); - BOOST_CHECK(v4.is_string()); - BOOST_CHECK(v5.is_string()); - BOOST_CHECK(v6.is_string()); + BOOST_TEST(v4.type() == toml::value_t::string); + BOOST_TEST(v5.type() == toml::value_t::string); + BOOST_TEST(v6.type() == toml::value_t::string); + BOOST_TEST(v4.is(toml::value_t::string)); + BOOST_TEST(v5.is(toml::value_t::string)); + BOOST_TEST(v6.is(toml::value_t::string)); + BOOST_TEST(v4.is()); + BOOST_TEST(v5.is()); + BOOST_TEST(v6.is()); + BOOST_TEST(v4.is_string()); + BOOST_TEST(v5.is_string()); + BOOST_TEST(v6.is_string()); - BOOST_CHECK_EQUAL(v4.cast(), "bar"); - BOOST_CHECK_EQUAL(v5.cast(), "bar"); - BOOST_CHECK_EQUAL(v6.cast(), "bar"); - BOOST_CHECK_EQUAL(v4.as_string(), "bar"); - BOOST_CHECK_EQUAL(v5.as_string(), "bar"); - BOOST_CHECK_EQUAL(v6.as_string(), "bar"); + BOOST_TEST(v4.cast() == "bar"); + BOOST_TEST(v5.cast() == "bar"); + BOOST_TEST(v6.cast() == "bar"); + BOOST_TEST(v4.as_string() == "bar"); + BOOST_TEST(v5.as_string() == "bar"); + BOOST_TEST(v6.as_string() == "bar"); v4.cast().str.at(2) = 'z'; v5.cast().str.at(2) = 'z'; v6.cast().str.at(2) = 'z'; - BOOST_CHECK_EQUAL(v4.type(), toml::value_t::string); - BOOST_CHECK_EQUAL(v5.type(), toml::value_t::string); - BOOST_CHECK_EQUAL(v6.type(), toml::value_t::string); - BOOST_CHECK(v4.is(toml::value_t::string)); - BOOST_CHECK(v5.is(toml::value_t::string)); - BOOST_CHECK(v6.is(toml::value_t::string)); - BOOST_CHECK(v4.is()); - BOOST_CHECK(v5.is()); - BOOST_CHECK(v6.is()); - BOOST_CHECK(v4.is_string()); - BOOST_CHECK(v5.is_string()); - BOOST_CHECK(v6.is_string()); + BOOST_TEST(v4.type() == toml::value_t::string); + BOOST_TEST(v5.type() == toml::value_t::string); + BOOST_TEST(v6.type() == toml::value_t::string); + BOOST_TEST(v4.is(toml::value_t::string)); + BOOST_TEST(v5.is(toml::value_t::string)); + BOOST_TEST(v6.is(toml::value_t::string)); + BOOST_TEST(v4.is()); + BOOST_TEST(v5.is()); + BOOST_TEST(v6.is()); + BOOST_TEST(v4.is_string()); + BOOST_TEST(v5.is_string()); + BOOST_TEST(v6.is_string()); - BOOST_CHECK_EQUAL(v4.as_string(), "baz"); - BOOST_CHECK_EQUAL(v5.as_string(), "baz"); - BOOST_CHECK_EQUAL(v6.as_string(), "baz"); + BOOST_TEST(v4.as_string() == "baz"); + BOOST_TEST(v5.as_string() == "baz"); + BOOST_TEST(v6.as_string() == "baz"); v1 = true; v2 = true; v3 = true; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::boolean); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::boolean); - BOOST_CHECK_EQUAL(v3.type(), toml::value_t::boolean); - BOOST_CHECK(v1.is(toml::value_t::boolean)); - BOOST_CHECK(v2.is(toml::value_t::boolean)); - BOOST_CHECK(v3.is(toml::value_t::boolean)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v3.is()); - BOOST_CHECK(v1.is_boolean()); - BOOST_CHECK(v2.is_boolean()); - BOOST_CHECK(v3.is_boolean()); + BOOST_TEST(v1.type() == toml::value_t::boolean); + BOOST_TEST(v2.type() == toml::value_t::boolean); + BOOST_TEST(v3.type() == toml::value_t::boolean); + BOOST_TEST(v1.is(toml::value_t::boolean)); + BOOST_TEST(v2.is(toml::value_t::boolean)); + BOOST_TEST(v3.is(toml::value_t::boolean)); + BOOST_TEST(v1.is()); + BOOST_TEST(v2.is()); + BOOST_TEST(v3.is()); + BOOST_TEST(v1.is_boolean()); + BOOST_TEST(v2.is_boolean()); + BOOST_TEST(v3.is_boolean()); - BOOST_CHECK_EQUAL(v1.cast(), true); - BOOST_CHECK_EQUAL(v2.cast(), true); - BOOST_CHECK_EQUAL(v3.cast(), true); - BOOST_CHECK_EQUAL(v1.as_boolean(), true); - BOOST_CHECK_EQUAL(v2.as_boolean(), true); - BOOST_CHECK_EQUAL(v3.as_boolean(), true); + BOOST_TEST(v1.cast() == true); + BOOST_TEST(v2.cast() == true); + BOOST_TEST(v3.cast() == true); + BOOST_TEST(v1.as_boolean() == true); + BOOST_TEST(v2.as_boolean() == true); + BOOST_TEST(v3.as_boolean() == true); #if __cplusplus >= 201703L std::string_view sv = "foo"; @@ -420,17 +429,17 @@ BOOST_AUTO_TEST_CASE(test_value_string) toml::value v7(sv); toml::value v8(sv, toml::string_t::literal); - BOOST_CHECK_EQUAL(v7.type(), toml::value_t::string); - BOOST_CHECK_EQUAL(v8.type(), toml::value_t::string); - BOOST_CHECK(v7.is(toml::value_t::string)); - BOOST_CHECK(v8.is(toml::value_t::string)); - BOOST_CHECK(v7.is()); - BOOST_CHECK(v8.is()); - BOOST_CHECK(v7.is_string()); - BOOST_CHECK(v8.is_string()); + BOOST_TEST(v7.type() == toml::value_t::string); + BOOST_TEST(v8.type() == toml::value_t::string); + BOOST_TEST(v7.is(toml::value_t::string)); + BOOST_TEST(v8.is(toml::value_t::string)); + BOOST_TEST(v7.is()); + BOOST_TEST(v8.is()); + BOOST_TEST(v7.is_string()); + BOOST_TEST(v8.is_string()); - BOOST_CHECK_EQUAL(v7.cast(), "foo"); - BOOST_CHECK_EQUAL(v8.cast(), "foo"); + BOOST_TEST(v7.cast() == "foo"); + BOOST_TEST(v8.cast() == "foo"); #endif } @@ -438,50 +447,50 @@ BOOST_AUTO_TEST_CASE(test_value_local_date) { toml::value v1(toml::local_date(2018, toml::month_t::Jan, 31)); - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::local_date); - BOOST_CHECK(v1.is(toml::value_t::local_date)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_local_date()); + BOOST_TEST(v1.type() == toml::value_t::local_date); + BOOST_TEST(v1.is(toml::value_t::local_date)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_local_date()); - BOOST_CHECK_EQUAL(v1.cast(), + BOOST_TEST(v1.cast() == toml::local_date(2018, toml::month_t::Jan, 31)); - BOOST_CHECK_EQUAL(v1.as_local_date(), + BOOST_TEST(v1.as_local_date() == toml::local_date(2018, toml::month_t::Jan, 31)); - BOOST_CHECK_EQUAL(v1.as_local_date(std::nothrow), + BOOST_TEST(v1.as_local_date(std::nothrow) == toml::local_date(2018, toml::month_t::Jan, 31)); v1 = toml::local_date(2018, toml::month_t::Apr, 1); - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::local_date); - BOOST_CHECK(v1.is(toml::value_t::local_date)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_local_date()); + BOOST_TEST(v1.type() == toml::value_t::local_date); + BOOST_TEST(v1.is(toml::value_t::local_date)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_local_date()); - BOOST_CHECK_EQUAL(v1.cast(), + BOOST_TEST(v1.cast() == toml::local_date(2018, toml::month_t::Apr, 1)); - BOOST_CHECK_EQUAL(v1.as_local_date(), + BOOST_TEST(v1.as_local_date() == toml::local_date(2018, toml::month_t::Apr, 1)); toml::value v2(v1); - BOOST_CHECK(v2 == v1); + BOOST_TEST(v2 == v1); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::local_date); - BOOST_CHECK(v2.is(toml::value_t::local_date)); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v2.is_local_date()); + BOOST_TEST(v2.type() == toml::value_t::local_date); + BOOST_TEST(v2.is(toml::value_t::local_date)); + BOOST_TEST(v2.is()); + BOOST_TEST(v2.is_local_date()); - BOOST_CHECK_EQUAL(v2.cast(), + BOOST_TEST(v2.cast() == toml::local_date(2018, toml::month_t::Apr, 1)); - BOOST_CHECK_EQUAL(v2.as_local_date(), + BOOST_TEST(v2.as_local_date() == toml::local_date(2018, toml::month_t::Apr, 1)); v1 = true; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::boolean); - BOOST_CHECK(v1.is(toml::value_t::boolean)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_boolean()); - BOOST_CHECK_EQUAL(v1.cast(), true); - BOOST_CHECK_EQUAL(v1.as_boolean(), true); + BOOST_TEST(v1.type() == toml::value_t::boolean); + BOOST_TEST(v1.is(toml::value_t::boolean)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_boolean()); + BOOST_TEST(v1.cast() == true); + BOOST_TEST(v1.as_boolean() == true); } BOOST_AUTO_TEST_CASE(test_value_local_time) @@ -490,63 +499,63 @@ BOOST_AUTO_TEST_CASE(test_value_local_time) toml::value v2(std::chrono::hours(12) + std::chrono::minutes(30) + std::chrono::seconds(45)); - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::local_time); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::local_time); - BOOST_CHECK(v1.is(toml::value_t::local_time)); - BOOST_CHECK(v2.is(toml::value_t::local_time)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v1.is_local_time()); - BOOST_CHECK(v2.is_local_time()); + BOOST_TEST(v1.type() == toml::value_t::local_time); + BOOST_TEST(v2.type() == toml::value_t::local_time); + BOOST_TEST(v1.is(toml::value_t::local_time)); + BOOST_TEST(v2.is(toml::value_t::local_time)); + BOOST_TEST(v1.is()); + BOOST_TEST(v2.is()); + BOOST_TEST(v1.is_local_time()); + BOOST_TEST(v2.is_local_time()); - BOOST_CHECK_EQUAL(v1.cast(), + BOOST_TEST(v1.cast() == toml::local_time(12, 30, 45)); - BOOST_CHECK_EQUAL(v1.as_local_time(), + BOOST_TEST(v1.as_local_time() == toml::local_time(12, 30, 45)); - BOOST_CHECK_EQUAL(v2.cast(), + BOOST_TEST(v2.cast() == toml::local_time(12, 30, 45)); - BOOST_CHECK_EQUAL(v2.as_local_time(), + BOOST_TEST(v2.as_local_time() == toml::local_time(12, 30, 45)); - BOOST_CHECK_EQUAL(v1.cast(), + BOOST_TEST(v1.cast() == v2.cast()); - BOOST_CHECK_EQUAL(v1.as_local_time(), + BOOST_TEST(v1.as_local_time() == v2.as_local_time()); - BOOST_CHECK_EQUAL(v1.as_local_time(std::nothrow), + BOOST_TEST(v1.as_local_time(std::nothrow) == v2.as_local_time(std::nothrow)); v1 = toml::local_time(1, 30, 0, /*ms*/ 100, /*us*/ 0); - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::local_time); - BOOST_CHECK(v1.is(toml::value_t::local_time)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_local_time()); - BOOST_CHECK_EQUAL(v1.cast(), + BOOST_TEST(v1.type() == toml::value_t::local_time); + BOOST_TEST(v1.is(toml::value_t::local_time)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_local_time()); + BOOST_TEST(v1.cast() == toml::local_time(1, 30, 0, 100, 0)); - BOOST_CHECK_EQUAL(v1.as_local_time(), + BOOST_TEST(v1.as_local_time() == toml::local_time(1, 30, 0, 100, 0)); toml::value v3(v1); - BOOST_CHECK(v3 == v1); + BOOST_TEST(v3 == v1); - BOOST_CHECK_EQUAL(v3.type(), toml::value_t::local_time); - BOOST_CHECK(v3.is(toml::value_t::local_time)); - BOOST_CHECK(v3.is()); - BOOST_CHECK(v3.is_local_time()); + BOOST_TEST(v3.type() == toml::value_t::local_time); + BOOST_TEST(v3.is(toml::value_t::local_time)); + BOOST_TEST(v3.is()); + BOOST_TEST(v3.is_local_time()); - BOOST_CHECK_EQUAL(v3.cast(), + BOOST_TEST(v3.cast() == toml::local_time(1, 30, 0, 100, 0)); - BOOST_CHECK_EQUAL(v3.as_local_time(), + BOOST_TEST(v3.as_local_time() == toml::local_time(1, 30, 0, 100, 0)); v1 = true; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::boolean); - BOOST_CHECK(v1.is(toml::value_t::boolean)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_boolean()); - BOOST_CHECK_EQUAL(v1.cast(), true); - BOOST_CHECK_EQUAL(v1.as_boolean(), true); + BOOST_TEST(v1.type() == toml::value_t::boolean); + BOOST_TEST(v1.is(toml::value_t::boolean)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_boolean()); + BOOST_TEST(v1.cast() == true); + BOOST_TEST(v1.as_boolean() == true); } BOOST_AUTO_TEST_CASE(test_value_local_datetime) @@ -556,20 +565,20 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime) toml::local_time(12, 30, 45) )); - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::local_datetime); - BOOST_CHECK(v1.is(toml::value_t::local_datetime)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_local_datetime()); + BOOST_TEST(v1.type() == toml::value_t::local_datetime); + BOOST_TEST(v1.is(toml::value_t::local_datetime)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_local_datetime()); - BOOST_CHECK_EQUAL(v1.cast(), + BOOST_TEST(v1.cast() == toml::local_datetime( toml::local_date(2018, toml::month_t::Jan, 31), toml::local_time(12, 30, 45))); - BOOST_CHECK_EQUAL(v1.as_local_datetime(), + BOOST_TEST(v1.as_local_datetime() == toml::local_datetime( toml::local_date(2018, toml::month_t::Jan, 31), toml::local_time(12, 30, 45))); - BOOST_CHECK_EQUAL(v1.as_local_datetime(std::nothrow), + BOOST_TEST(v1.as_local_datetime(std::nothrow) == toml::local_datetime( toml::local_date(2018, toml::month_t::Jan, 31), toml::local_time(12, 30, 45))); @@ -579,45 +588,45 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime) toml::local_date(2018, toml::month_t::Apr, 1), toml::local_time(1, 15, 30)); - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::local_datetime); - BOOST_CHECK(v1.is(toml::value_t::local_datetime)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_local_datetime()); + BOOST_TEST(v1.type() == toml::value_t::local_datetime); + BOOST_TEST(v1.is(toml::value_t::local_datetime)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_local_datetime()); - BOOST_CHECK_EQUAL(v1.cast(), + BOOST_TEST(v1.cast() == toml::local_datetime( toml::local_date(2018, toml::month_t::Apr, 1), toml::local_time(1, 15, 30))); - BOOST_CHECK_EQUAL(v1.as_local_datetime(), + BOOST_TEST(v1.as_local_datetime() == toml::local_datetime( toml::local_date(2018, toml::month_t::Apr, 1), toml::local_time(1, 15, 30))); toml::value v2(v1); - BOOST_CHECK(v2 == v1); + BOOST_TEST(v2 == v1); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::local_datetime); - BOOST_CHECK(v2.is(toml::value_t::local_datetime)); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v2.is_local_datetime()); + BOOST_TEST(v2.type() == toml::value_t::local_datetime); + BOOST_TEST(v2.is(toml::value_t::local_datetime)); + BOOST_TEST(v2.is()); + BOOST_TEST(v2.is_local_datetime()); - BOOST_CHECK_EQUAL(v2.cast(), + BOOST_TEST(v2.cast() == toml::local_datetime( toml::local_date(2018, toml::month_t::Apr, 1), toml::local_time(1, 15, 30))); - BOOST_CHECK_EQUAL(v2.as_local_datetime(), + BOOST_TEST(v2.as_local_datetime() == toml::local_datetime( toml::local_date(2018, toml::month_t::Apr, 1), toml::local_time(1, 15, 30))); v1 = true; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::boolean); - BOOST_CHECK(v1.is(toml::value_t::boolean)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_boolean()); - BOOST_CHECK_EQUAL(v1.cast(), true); - BOOST_CHECK_EQUAL(v1.as_boolean(), true); + BOOST_TEST(v1.type() == toml::value_t::boolean); + BOOST_TEST(v1.is(toml::value_t::boolean)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_boolean()); + BOOST_TEST(v1.cast() == true); + BOOST_TEST(v1.as_boolean() == true); } BOOST_AUTO_TEST_CASE(test_value_offset_datetime) @@ -628,24 +637,24 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime) toml::time_offset(9, 0) )); - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::offset_datetime); - BOOST_CHECK(v1.is(toml::value_t::offset_datetime)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_offset_datetime()); + BOOST_TEST(v1.type() == toml::value_t::offset_datetime); + BOOST_TEST(v1.is(toml::value_t::offset_datetime)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_offset_datetime()); - BOOST_CHECK_EQUAL(v1.cast(), + BOOST_TEST(v1.cast() == toml::offset_datetime( toml::local_date(2018, toml::month_t::Jan, 31), toml::local_time(12, 30, 45), toml::time_offset(9, 0) )); - BOOST_CHECK_EQUAL(v1.as_offset_datetime(), + BOOST_TEST(v1.as_offset_datetime() == toml::offset_datetime( toml::local_date(2018, toml::month_t::Jan, 31), toml::local_time(12, 30, 45), toml::time_offset(9, 0) )); - BOOST_CHECK_EQUAL(v1.as_offset_datetime(std::nothrow), + BOOST_TEST(v1.as_offset_datetime(std::nothrow) == toml::offset_datetime( toml::local_date(2018, toml::month_t::Jan, 31), toml::local_time(12, 30, 45), @@ -658,17 +667,17 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime) toml::local_time(1, 15, 30), toml::time_offset(9, 0)); - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::offset_datetime); - BOOST_CHECK(v1.is(toml::value_t::offset_datetime)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_offset_datetime()); + BOOST_TEST(v1.type() == toml::value_t::offset_datetime); + BOOST_TEST(v1.is(toml::value_t::offset_datetime)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_offset_datetime()); - BOOST_CHECK_EQUAL(v1.cast(), + BOOST_TEST(v1.cast() == toml::offset_datetime( toml::local_date(2018, toml::month_t::Apr, 1), toml::local_time(1, 15, 30), toml::time_offset(9, 0))); - BOOST_CHECK_EQUAL(v1.as_offset_datetime(), + BOOST_TEST(v1.as_offset_datetime() == toml::offset_datetime( toml::local_date(2018, toml::month_t::Apr, 1), toml::local_time(1, 15, 30), @@ -676,31 +685,31 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime) toml::value v2(v1); - BOOST_CHECK(v2 == v1); + BOOST_TEST(v2 == v1); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::offset_datetime); - BOOST_CHECK(v2.is(toml::value_t::offset_datetime)); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v2.is_offset_datetime()); + BOOST_TEST(v2.type() == toml::value_t::offset_datetime); + BOOST_TEST(v2.is(toml::value_t::offset_datetime)); + BOOST_TEST(v2.is()); + BOOST_TEST(v2.is_offset_datetime()); - BOOST_CHECK_EQUAL(v2.cast(), + BOOST_TEST(v2.cast() == toml::offset_datetime( toml::local_date(2018, toml::month_t::Apr, 1), toml::local_time(1, 15, 30), toml::time_offset(9, 0))); - BOOST_CHECK_EQUAL(v2.as_offset_datetime(), + BOOST_TEST(v2.as_offset_datetime() == toml::offset_datetime( toml::local_date(2018, toml::month_t::Apr, 1), toml::local_time(1, 15, 30), toml::time_offset(9, 0))); v1 = true; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::boolean); - BOOST_CHECK(v1.is(toml::value_t::boolean)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_boolean()); - BOOST_CHECK_EQUAL(v1.cast(), true); - BOOST_CHECK_EQUAL(v1.as_boolean(), true); + BOOST_TEST(v1.type() == toml::value_t::boolean); + BOOST_TEST(v1.is(toml::value_t::boolean)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_boolean()); + BOOST_TEST(v1.cast() == true); + BOOST_TEST(v1.as_boolean() == true); } BOOST_AUTO_TEST_CASE(test_value_array) @@ -709,181 +718,181 @@ BOOST_AUTO_TEST_CASE(test_value_array) toml::value v1(v); toml::value v2{6,7,8,9,0}; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::array); - BOOST_CHECK(v1.is(toml::value_t::array)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_array()); + BOOST_TEST(v1.type() == toml::value_t::array); + BOOST_TEST(v1.is(toml::value_t::array)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_array()); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::array); - BOOST_CHECK(v2.is(toml::value_t::array)); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v2.is_array()); + BOOST_TEST(v2.type() == toml::value_t::array); + BOOST_TEST(v2.is(toml::value_t::array)); + BOOST_TEST(v2.is()); + BOOST_TEST(v2.is_array()); - BOOST_CHECK_EQUAL(v1.cast().at(0).cast(), 1); - BOOST_CHECK_EQUAL(v1.cast().at(1).cast(), 2); - BOOST_CHECK_EQUAL(v1.cast().at(2).cast(), 3); - BOOST_CHECK_EQUAL(v1.cast().at(3).cast(), 4); - BOOST_CHECK_EQUAL(v1.cast().at(4).cast(), 5); - BOOST_CHECK_EQUAL(v1.as_array().at(0).as_integer(), 1); - BOOST_CHECK_EQUAL(v1.as_array().at(1).as_integer(), 2); - BOOST_CHECK_EQUAL(v1.as_array().at(2).as_integer(), 3); - BOOST_CHECK_EQUAL(v1.as_array().at(3).as_integer(), 4); - BOOST_CHECK_EQUAL(v1.as_array().at(4).as_integer(), 5); - BOOST_CHECK_EQUAL(v1.as_array(std::nothrow).at(0).as_integer(), 1); - BOOST_CHECK_EQUAL(v1.as_array(std::nothrow).at(1).as_integer(), 2); - BOOST_CHECK_EQUAL(v1.as_array(std::nothrow).at(2).as_integer(), 3); - BOOST_CHECK_EQUAL(v1.as_array(std::nothrow).at(3).as_integer(), 4); - BOOST_CHECK_EQUAL(v1.as_array(std::nothrow).at(4).as_integer(), 5); + BOOST_TEST(v1.cast().at(0).cast() == 1); + BOOST_TEST(v1.cast().at(1).cast() == 2); + BOOST_TEST(v1.cast().at(2).cast() == 3); + BOOST_TEST(v1.cast().at(3).cast() == 4); + BOOST_TEST(v1.cast().at(4).cast() == 5); + BOOST_TEST(v1.as_array().at(0).as_integer() == 1); + BOOST_TEST(v1.as_array().at(1).as_integer() == 2); + BOOST_TEST(v1.as_array().at(2).as_integer() == 3); + BOOST_TEST(v1.as_array().at(3).as_integer() == 4); + BOOST_TEST(v1.as_array().at(4).as_integer() == 5); + BOOST_TEST(v1.as_array(std::nothrow).at(0).as_integer() == 1); + BOOST_TEST(v1.as_array(std::nothrow).at(1).as_integer() == 2); + BOOST_TEST(v1.as_array(std::nothrow).at(2).as_integer() == 3); + BOOST_TEST(v1.as_array(std::nothrow).at(3).as_integer() == 4); + BOOST_TEST(v1.as_array(std::nothrow).at(4).as_integer() == 5); - BOOST_CHECK_EQUAL(v2.cast().at(0).cast(), 6); - BOOST_CHECK_EQUAL(v2.cast().at(1).cast(), 7); - BOOST_CHECK_EQUAL(v2.cast().at(2).cast(), 8); - BOOST_CHECK_EQUAL(v2.cast().at(3).cast(), 9); - BOOST_CHECK_EQUAL(v2.cast().at(4).cast(), 0); + BOOST_TEST(v2.cast().at(0).cast() == 6); + BOOST_TEST(v2.cast().at(1).cast() == 7); + BOOST_TEST(v2.cast().at(2).cast() == 8); + BOOST_TEST(v2.cast().at(3).cast() == 9); + BOOST_TEST(v2.cast().at(4).cast() == 0); v1 = {6,7,8,9,0}; v2 = v; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::array); - BOOST_CHECK(v1.is(toml::value_t::array)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_array()); + BOOST_TEST(v1.type() == toml::value_t::array); + BOOST_TEST(v1.is(toml::value_t::array)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_array()); - BOOST_CHECK_EQUAL(v2.type(), toml::value_t::array); - BOOST_CHECK(v2.is(toml::value_t::array)); - BOOST_CHECK(v2.is()); - BOOST_CHECK(v2.is_array()); + BOOST_TEST(v2.type() == toml::value_t::array); + BOOST_TEST(v2.is(toml::value_t::array)); + BOOST_TEST(v2.is()); + BOOST_TEST(v2.is_array()); - BOOST_CHECK_EQUAL(v1.cast().at(0).cast(), 6); - BOOST_CHECK_EQUAL(v1.cast().at(1).cast(), 7); - BOOST_CHECK_EQUAL(v1.cast().at(2).cast(), 8); - BOOST_CHECK_EQUAL(v1.cast().at(3).cast(), 9); - BOOST_CHECK_EQUAL(v1.cast().at(4).cast(), 0); - BOOST_CHECK_EQUAL(v1.as_array().at(0).as_integer(), 6); - BOOST_CHECK_EQUAL(v1.as_array().at(1).as_integer(), 7); - BOOST_CHECK_EQUAL(v1.as_array().at(2).as_integer(), 8); - BOOST_CHECK_EQUAL(v1.as_array().at(3).as_integer(), 9); - BOOST_CHECK_EQUAL(v1.as_array().at(4).as_integer(), 0); + BOOST_TEST(v1.cast().at(0).cast() == 6); + BOOST_TEST(v1.cast().at(1).cast() == 7); + BOOST_TEST(v1.cast().at(2).cast() == 8); + BOOST_TEST(v1.cast().at(3).cast() == 9); + BOOST_TEST(v1.cast().at(4).cast() == 0); + BOOST_TEST(v1.as_array().at(0).as_integer() == 6); + BOOST_TEST(v1.as_array().at(1).as_integer() == 7); + BOOST_TEST(v1.as_array().at(2).as_integer() == 8); + BOOST_TEST(v1.as_array().at(3).as_integer() == 9); + BOOST_TEST(v1.as_array().at(4).as_integer() == 0); - BOOST_CHECK_EQUAL(v2.cast().at(0).cast(), 1); - BOOST_CHECK_EQUAL(v2.cast().at(1).cast(), 2); - BOOST_CHECK_EQUAL(v2.cast().at(2).cast(), 3); - BOOST_CHECK_EQUAL(v2.cast().at(3).cast(), 4); - BOOST_CHECK_EQUAL(v2.cast().at(4).cast(), 5); - BOOST_CHECK_EQUAL(v2.as_array().at(0).as_integer(), 1); - BOOST_CHECK_EQUAL(v2.as_array().at(1).as_integer(), 2); - BOOST_CHECK_EQUAL(v2.as_array().at(2).as_integer(), 3); - BOOST_CHECK_EQUAL(v2.as_array().at(3).as_integer(), 4); - BOOST_CHECK_EQUAL(v2.as_array().at(4).as_integer(), 5); + BOOST_TEST(v2.cast().at(0).cast() == 1); + BOOST_TEST(v2.cast().at(1).cast() == 2); + BOOST_TEST(v2.cast().at(2).cast() == 3); + BOOST_TEST(v2.cast().at(3).cast() == 4); + BOOST_TEST(v2.cast().at(4).cast() == 5); + BOOST_TEST(v2.as_array().at(0).as_integer() == 1); + BOOST_TEST(v2.as_array().at(1).as_integer() == 2); + BOOST_TEST(v2.as_array().at(2).as_integer() == 3); + BOOST_TEST(v2.as_array().at(3).as_integer() == 4); + BOOST_TEST(v2.as_array().at(4).as_integer() == 5); toml::value v3(v1); - BOOST_CHECK(v3 == v1); + BOOST_TEST(v3 == v1); - BOOST_CHECK_EQUAL(v3.type(), toml::value_t::array); - BOOST_CHECK(v3.is(toml::value_t::array)); - BOOST_CHECK(v3.is()); - BOOST_CHECK(v3.is_array()); + BOOST_TEST(v3.type() == toml::value_t::array); + BOOST_TEST(v3.is(toml::value_t::array)); + BOOST_TEST(v3.is()); + BOOST_TEST(v3.is_array()); - BOOST_CHECK_EQUAL(v3.cast().at(0).cast(), 6); - BOOST_CHECK_EQUAL(v3.cast().at(1).cast(), 7); - BOOST_CHECK_EQUAL(v3.cast().at(2).cast(), 8); - BOOST_CHECK_EQUAL(v3.cast().at(3).cast(), 9); - BOOST_CHECK_EQUAL(v3.cast().at(4).cast(), 0); - BOOST_CHECK_EQUAL(v3.as_array().at(0).as_integer(), 6); - BOOST_CHECK_EQUAL(v3.as_array().at(1).as_integer(), 7); - BOOST_CHECK_EQUAL(v3.as_array().at(2).as_integer(), 8); - BOOST_CHECK_EQUAL(v3.as_array().at(3).as_integer(), 9); - BOOST_CHECK_EQUAL(v3.as_array().at(4).as_integer(), 0); + BOOST_TEST(v3.cast().at(0).cast() == 6); + BOOST_TEST(v3.cast().at(1).cast() == 7); + BOOST_TEST(v3.cast().at(2).cast() == 8); + BOOST_TEST(v3.cast().at(3).cast() == 9); + BOOST_TEST(v3.cast().at(4).cast() == 0); + BOOST_TEST(v3.as_array().at(0).as_integer() == 6); + BOOST_TEST(v3.as_array().at(1).as_integer() == 7); + BOOST_TEST(v3.as_array().at(2).as_integer() == 8); + BOOST_TEST(v3.as_array().at(3).as_integer() == 9); + BOOST_TEST(v3.as_array().at(4).as_integer() == 0); v1 = true; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::boolean); - BOOST_CHECK(v1.is(toml::value_t::boolean)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_boolean()); - BOOST_CHECK_EQUAL(v1.cast(), true); - BOOST_CHECK_EQUAL(v1.as_boolean(), true); + BOOST_TEST(v1.type() == toml::value_t::boolean); + BOOST_TEST(v1.is(toml::value_t::boolean)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_boolean()); + BOOST_TEST(v1.cast() == true); + BOOST_TEST(v1.as_boolean() == true); } BOOST_AUTO_TEST_CASE(test_value_table) { toml::value v1{{"foo", 42}, {"bar", 3.14}, {"baz", "qux"}}; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::table); - BOOST_CHECK(v1.is(toml::value_t::table)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_table()); + BOOST_TEST(v1.type() == toml::value_t::table); + BOOST_TEST(v1.is(toml::value_t::table)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_table()); - BOOST_CHECK_EQUAL(v1.cast().at("foo").cast(), 42); - BOOST_CHECK_EQUAL(v1.cast().at("bar").cast(), 3.14); - BOOST_CHECK_EQUAL(v1.cast().at("baz").cast().str, "qux"); - BOOST_CHECK_EQUAL(v1.as_table().at("foo").as_integer(), 42); - BOOST_CHECK_EQUAL(v1.as_table().at("bar").as_floating(), 3.14); - BOOST_CHECK_EQUAL(v1.as_table().at("baz").as_string().str, "qux"); - BOOST_CHECK_EQUAL(v1.as_table(std::nothrow).at("foo").as_integer(), 42); - BOOST_CHECK_EQUAL(v1.as_table(std::nothrow).at("bar").as_floating(), 3.14); - BOOST_CHECK_EQUAL(v1.as_table(std::nothrow).at("baz").as_string().str, "qux"); + BOOST_TEST(v1.cast().at("foo").cast() == 42); + BOOST_TEST(v1.cast().at("bar").cast() == 3.14); + BOOST_TEST(v1.cast().at("baz").cast().str == "qux"); + BOOST_TEST(v1.as_table().at("foo").as_integer() == 42); + BOOST_TEST(v1.as_table().at("bar").as_floating() == 3.14); + BOOST_TEST(v1.as_table().at("baz").as_string().str == "qux"); + BOOST_TEST(v1.as_table(std::nothrow).at("foo").as_integer() == 42); + BOOST_TEST(v1.as_table(std::nothrow).at("bar").as_floating() == 3.14); + BOOST_TEST(v1.as_table(std::nothrow).at("baz").as_string().str == "qux"); v1 = {{"foo", 2.71}, {"bar", 54}, {"baz", "quux"}}; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::table); - BOOST_CHECK(v1.is(toml::value_t::table)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_table()); + BOOST_TEST(v1.type() == toml::value_t::table); + BOOST_TEST(v1.is(toml::value_t::table)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_table()); - BOOST_CHECK_EQUAL(v1.cast().at("foo").cast(), 2.71); - BOOST_CHECK_EQUAL(v1.cast().at("bar").cast(), 54); - BOOST_CHECK_EQUAL(v1.cast().at("baz").cast().str, "quux"); - BOOST_CHECK_EQUAL(v1.as_table().at("foo").as_floating(), 2.71); - BOOST_CHECK_EQUAL(v1.as_table().at("bar").as_integer(), 54); - BOOST_CHECK_EQUAL(v1.as_table().at("baz").as_string().str, "quux"); + BOOST_TEST(v1.cast().at("foo").cast() == 2.71); + BOOST_TEST(v1.cast().at("bar").cast() == 54); + BOOST_TEST(v1.cast().at("baz").cast().str == "quux"); + BOOST_TEST(v1.as_table().at("foo").as_floating() == 2.71); + BOOST_TEST(v1.as_table().at("bar").as_integer() == 54); + BOOST_TEST(v1.as_table().at("baz").as_string().str == "quux"); v1 = toml::table{{"foo", 2.71}, {"bar", 54}, {"baz", "quux"}}; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::table); - BOOST_CHECK(v1.is(toml::value_t::table)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_table()); + BOOST_TEST(v1.type() == toml::value_t::table); + BOOST_TEST(v1.is(toml::value_t::table)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_table()); - BOOST_CHECK_EQUAL(v1.cast().at("foo").cast(), 2.71); - BOOST_CHECK_EQUAL(v1.cast().at("bar").cast(), 54); - BOOST_CHECK_EQUAL(v1.cast().at("baz").cast().str, "quux"); - BOOST_CHECK_EQUAL(v1.as_table().at("foo").as_floating(), 2.71); - BOOST_CHECK_EQUAL(v1.as_table().at("bar").as_integer(), 54); - BOOST_CHECK_EQUAL(v1.as_table().at("baz").as_string().str, "quux"); + BOOST_TEST(v1.cast().at("foo").cast() == 2.71); + BOOST_TEST(v1.cast().at("bar").cast() == 54); + BOOST_TEST(v1.cast().at("baz").cast().str == "quux"); + BOOST_TEST(v1.as_table().at("foo").as_floating() == 2.71); + BOOST_TEST(v1.as_table().at("bar").as_integer() == 54); + BOOST_TEST(v1.as_table().at("baz").as_string().str == "quux"); toml::value v3(v1); - BOOST_CHECK(v3 == v1); + BOOST_TEST(v3 == v1); - BOOST_CHECK_EQUAL(v3.type(), toml::value_t::table); - BOOST_CHECK(v3.is(toml::value_t::table)); - BOOST_CHECK(v3.is()); - BOOST_CHECK(v3.is_table()); + BOOST_TEST(v3.type() == toml::value_t::table); + BOOST_TEST(v3.is(toml::value_t::table)); + BOOST_TEST(v3.is()); + BOOST_TEST(v3.is_table()); - BOOST_CHECK_EQUAL(v3.cast().at("foo").cast(), 2.71); - BOOST_CHECK_EQUAL(v3.cast().at("bar").cast(), 54); - BOOST_CHECK_EQUAL(v3.cast().at("baz").cast().str, "quux"); - BOOST_CHECK_EQUAL(v3.as_table().at("foo").as_floating(), 2.71); - BOOST_CHECK_EQUAL(v3.as_table().at("bar").as_integer(), 54); - BOOST_CHECK_EQUAL(v3.as_table().at("baz").as_string().str, "quux"); + BOOST_TEST(v3.cast().at("foo").cast() == 2.71); + BOOST_TEST(v3.cast().at("bar").cast() == 54); + BOOST_TEST(v3.cast().at("baz").cast().str == "quux"); + BOOST_TEST(v3.as_table().at("foo").as_floating() == 2.71); + BOOST_TEST(v3.as_table().at("bar").as_integer() == 54); + BOOST_TEST(v3.as_table().at("baz").as_string().str == "quux"); v1 = true; - BOOST_CHECK_EQUAL(v1.type(), toml::value_t::boolean); - BOOST_CHECK(v1.is(toml::value_t::boolean)); - BOOST_CHECK(v1.is()); - BOOST_CHECK(v1.is_boolean()); - BOOST_CHECK_EQUAL(v1.cast(), true); - BOOST_CHECK_EQUAL(v1.as_boolean(), true); + BOOST_TEST(v1.type() == toml::value_t::boolean); + BOOST_TEST(v1.is(toml::value_t::boolean)); + BOOST_TEST(v1.is()); + BOOST_TEST(v1.is_boolean()); + BOOST_TEST(v1.cast() == true); + BOOST_TEST(v1.as_boolean() == true); } BOOST_AUTO_TEST_CASE(test_value_empty) { toml::value v1; - BOOST_CHECK(v1.is_uninitialized()); - BOOST_CHECK(v1.is(toml::value_t::empty)); + BOOST_TEST(v1.is_uninitialized()); + BOOST_TEST(v1.is(toml::value_t::empty)); BOOST_CHECK_THROW(v1.as_boolean(), toml::type_error); BOOST_CHECK_THROW(v1.as_integer(), toml::type_error);