AuroraMiddleware/toml11
1
0
Fork 0
mirror of https://github.com/ToruNiina/toml11.git synced 2024-11-09 22:30:07 +00:00
Code Issues Packages Projects Releases Wiki Activity
e064a5c371
toml11/tests/test_parse_file.cpp

1030 lines
39 KiB
C++
Raw Normal View History

Consistent unit test header inclusion order This patch consistently changes the inclusion order for unit test files to the following: 1. The header of the unit under test (using <> includes). 2. The unit_test.hpp header (using "" includes). 3. Any additional auxiliary test headers (using "" includes and sorted alphabetically). 4. Additional system headers needed for the test (using <> includes and sorted alphabetically). 5. Conditionally included system headers (using <> includes). Putting the unit under test's header at the very beginning has the advantage of also testing that the header is self-contained. It also makes it very quick to tell what unit is tested in this file.
2022-09-16 11:16:01 +00:00
#include <toml.hpp>
Factor redundant test boilerplate out into unit_test.hpp helper
2022-09-16 10:51:41 +00:00
#include "unit_test.hpp"
Consistent unit test header inclusion order This patch consistently changes the inclusion order for unit test files to the following: 1. The header of the unit under test (using <> includes). 2. The unit_test.hpp header (using "" includes). 3. Any additional auxiliary test headers (using "" includes and sorted alphabetically). 4. Additional system headers needed for the test (using <> includes and sorted alphabetically). 5. Conditionally included system headers (using <> includes). Putting the unit under test's header at the very beginning has the advantage of also testing that the header is self-contained. It also makes it very quick to tell what unit is tested in this file.
2022-09-16 11:16:01 +00:00
#include <deque>
add parse() function
2017-05-12 11:49:47 +00:00
#include <fstream>
Consistent unit test header inclusion order This patch consistently changes the inclusion order for unit test files to the following: 1. The header of the unit under test (using <> includes). 2. The unit_test.hpp header (using "" includes). 3. Any additional auxiliary test headers (using "" includes and sorted alphabetically). 4. Additional system headers needed for the test (using <> includes and sorted alphabetically). 5. Conditionally included system headers (using <> includes). Putting the unit under test's header at the very beginning has the advantage of also testing that the header is self-contained. It also makes it very quick to tell what unit is tested in this file.
2022-09-16 11:16:01 +00:00
#include <iostream>
test: add test for custom basic_value type
2019-06-15 11:25:19 +00:00
#include <map>
add parse() function
2017-05-12 11:49:47 +00:00
BOOST_AUTO_TEST_CASE(test_example)
{
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
const auto data = toml::parse(testinput("example.toml"));
add parse() function
2017-05-12 11:49:47 +00:00
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "title") == "TOML Example");
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
const auto& owner = toml::find(data, "owner");
add parse() function
2017-05-12 11:49:47 +00:00
{
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(owner, "name") == "Tom Preston-Werner");
BOOST_TEST(toml::find<std::string>(owner, "organization") == "GitHub");
BOOST_TEST(toml::find<std::string>(owner, "bio") ==
add parse() function
2017-05-12 11:49:47 +00:00
"GitHub Cofounder & CEO\nLikes tater tots and beer.");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<toml::offset_datetime>(owner, "dob") ==
turn test_parse_file on the required change is; - change Datetime -> offset_datetime and construct correctly.
2018-12-12 17:26:55 +00:00
toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27),
toml::local_time(7, 32, 0), toml::time_offset(0, 0)));
add parse() function
2017-05-12 11:49:47 +00:00
}
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
const auto& database = toml::find(data, "database");
add parse() function
2017-05-12 11:49:47 +00:00
{
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(database, "server") == "192.168.1.1");
add parse() function
2017-05-12 11:49:47 +00:00
const std::vector<int> expected_ports{8001, 8001, 8002};
refactor: replace BOOST_CHECK_EQUAL by BOOST_TEST
2019-06-21 06:58:22 +00:00
BOOST_CHECK(toml::find<std::vector<int>>(database, "ports") == expected_ports);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<int >(database, "connection_max") == 5000);
BOOST_TEST(toml::find<bool>(database, "enabled") == true);
add parse() function
2017-05-12 11:49:47 +00:00
}
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
const auto& servers = toml::find(data, "servers");
add parse() function
2017-05-12 11:49:47 +00:00
{
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
toml::table alpha = toml::find<toml::table>(servers, "alpha");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::string>(alpha.at("ip")) == "10.0.0.1");
BOOST_TEST(toml::get<std::string>(alpha.at("dc")) == "eqdc10");
add parse() function
2017-05-12 11:49:47 +00:00
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
toml::table beta = toml::find<toml::table>(servers, "beta");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::string>(beta.at("ip")) == "10.0.0.2");
BOOST_TEST(toml::get<std::string>(beta.at("dc")) == "eqdc10");
BOOST_TEST(toml::get<std::string>(beta.at("country")) == "\xE4\xB8\xAD\xE5\x9B\xBD");
add parse() function
2017-05-12 11:49:47 +00:00
}
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
const auto& clients = toml::find(data, "clients");
add parse() function
2017-05-12 11:49:47 +00:00
{
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
toml::array clients_data = toml::find<toml::array>(clients, "data");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
add parse() function
2017-05-12 11:49:47 +00:00
std::vector<std::string> expected_name{"gamma", "delta"};
refactor: replace BOOST_CHECK_EQUAL by BOOST_TEST
2019-06-21 06:58:22 +00:00
BOOST_CHECK(toml::get<std::vector<std::string>>(clients_data.at(0)) == expected_name);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
add parse() function
2017-05-12 11:49:47 +00:00
std::vector<int> expected_number{1, 2};
refactor: replace BOOST_CHECK_EQUAL by BOOST_TEST
2019-06-21 06:58:22 +00:00
BOOST_CHECK(toml::get<std::vector<int>>(clients_data.at(1)) == expected_number);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
add parse() function
2017-05-12 11:49:47 +00:00
std::vector<std::string> expected_hosts{"alpha", "omega"};
refactor: replace BOOST_CHECK_EQUAL by BOOST_TEST
2019-06-21 06:58:22 +00:00
BOOST_CHECK(toml::find<std::vector<std::string>>(clients, "hosts") == expected_hosts);
add parse() function
2017-05-12 11:49:47 +00:00
}
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
std::vector<toml::table> products =
toml::find<std::vector<toml::table>>(data, "products");
add parse() function
2017-05-12 11:49:47 +00:00
{
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::string>(products.at(0).at("name")) == "Hammer");
BOOST_TEST(toml::get<std::int64_t>(products.at(0).at("sku")) == 738594937);
add parse() function
2017-05-12 11:49:47 +00:00
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::string>(products.at(1).at("name")) == "Nail");
BOOST_TEST(toml::get<std::int64_t>(products.at(1).at("sku")) == 284758393);
BOOST_TEST(toml::get<std::string>(products.at(1).at("color")) == "gray");
add parse() function
2017-05-12 11:49:47 +00:00
}
}
add test for stream input
2017-05-19 05:16:12 +00:00
BOOST_AUTO_TEST_CASE(test_example_stream)
{
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
std::ifstream ifs(testinput("example.toml"), std::ios::binary);
add test for stream input
2017-05-19 05:16:12 +00:00
const auto data = toml::parse(ifs);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "title") == "TOML Example");
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
const auto& owner = toml::find(data, "owner");
add test for stream input
2017-05-19 05:16:12 +00:00
{
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(owner, "name") == "Tom Preston-Werner");
BOOST_TEST(toml::find<std::string>(owner, "organization") == "GitHub");
BOOST_TEST(toml::find<std::string>(owner, "bio") ==
add test for stream input
2017-05-19 05:16:12 +00:00
"GitHub Cofounder & CEO\nLikes tater tots and beer.");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<toml::offset_datetime>(owner, "dob") ==
turn test_parse_file on the required change is; - change Datetime -> offset_datetime and construct correctly.
2018-12-12 17:26:55 +00:00
toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27),
toml::local_time(7, 32, 0), toml::time_offset(0, 0)));
add test for stream input
2017-05-19 05:16:12 +00:00
}
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
const auto& database = toml::find(data, "database");
add test for stream input
2017-05-19 05:16:12 +00:00
{
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(database, "server") == "192.168.1.1");
add test for stream input
2017-05-19 05:16:12 +00:00
const std::vector<int> expected_ports{8001, 8001, 8002};
refactor: replace BOOST_CHECK_EQUAL by BOOST_TEST
2019-06-21 06:58:22 +00:00
BOOST_CHECK(toml::find<std::vector<int>>(database, "ports") == expected_ports);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<int >(database, "connection_max") == 5000);
BOOST_TEST(toml::find<bool>(database, "enabled") == true);
add test for stream input
2017-05-19 05:16:12 +00:00
}
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
const auto& servers = toml::find(data, "servers");
add test for stream input
2017-05-19 05:16:12 +00:00
{
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
toml::table alpha = toml::find<toml::table>(servers, "alpha");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::string>(alpha.at("ip")) == "10.0.0.1");
BOOST_TEST(toml::get<std::string>(alpha.at("dc")) == "eqdc10");
add test for stream input
2017-05-19 05:16:12 +00:00
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
toml::table beta = toml::find<toml::table>(servers, "beta");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::string>(beta.at("ip")) == "10.0.0.2");
BOOST_TEST(toml::get<std::string>(beta.at("dc")) == "eqdc10");
BOOST_TEST(toml::get<std::string>(beta.at("country")) == "\xE4\xB8\xAD\xE5\x9B\xBD");
add test for stream input
2017-05-19 05:16:12 +00:00
}
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
const auto& clients = toml::find(data, "clients");
add test for stream input
2017-05-19 05:16:12 +00:00
{
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
toml::array clients_data = toml::find<toml::array>(clients, "data");
add test for stream input
2017-05-19 05:16:12 +00:00
std::vector<std::string> expected_name{"gamma", "delta"};
refactor: replace BOOST_CHECK_EQUAL by BOOST_TEST
2019-06-21 06:58:22 +00:00
BOOST_CHECK(toml::get<std::vector<std::string>>(clients_data.at(0)) == expected_name);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
add test for stream input
2017-05-19 05:16:12 +00:00
std::vector<int> expected_number{1, 2};
refactor: replace BOOST_CHECK_EQUAL by BOOST_TEST
2019-06-21 06:58:22 +00:00
BOOST_CHECK(toml::get<std::vector<int>>(clients_data.at(1)) == expected_number);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
add test for stream input
2017-05-19 05:16:12 +00:00
std::vector<std::string> expected_hosts{"alpha", "omega"};
refactor: replace BOOST_CHECK_EQUAL by BOOST_TEST
2019-06-21 06:58:22 +00:00
BOOST_CHECK(toml::find<std::vector<std::string>>(clients, "hosts") == expected_hosts);
add test for stream input
2017-05-19 05:16:12 +00:00
}
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
std::vector<toml::table> products =
toml::find<std::vector<toml::table>>(data, "products");
add test for stream input
2017-05-19 05:16:12 +00:00
{
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::string>(products.at(0).at("name")) ==
add test for stream input
2017-05-19 05:16:12 +00:00
"Hammer");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::int64_t>(products.at(0).at("sku")) ==
add test for stream input
2017-05-19 05:16:12 +00:00
738594937);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::string>(products.at(1).at("name")) ==
add test for stream input
2017-05-19 05:16:12 +00:00
"Nail");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::int64_t>(products.at(1).at("sku")) ==
add test for stream input
2017-05-19 05:16:12 +00:00
284758393);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::string>(products.at(1).at("color")) ==
add test for stream input
2017-05-19 05:16:12 +00:00
"gray");
}
}
feat: Add a parse(FILE *) interface The fstream classes are notorious for their non-existent error handling. This adds a C-style fILE * IO (fopen(), etc.) alternative interface, so that if a user needs reliable error handling, they can use that, albeit more inconvenient, but more robust approach.
2022-06-30 11:53:32 +00:00
BOOST_AUTO_TEST_CASE(test_example_file_pointer)
{
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
FILE * file = fopen(testinput("example.toml").c_str(), "rb");
feat: Add a parse(FILE *) interface The fstream classes are notorious for their non-existent error handling. This adds a C-style fILE * IO (fopen(), etc.) alternative interface, so that if a user needs reliable error handling, they can use that, albeit more inconvenient, but more robust approach.
2022-06-30 11:53:32 +00:00
const auto data = toml::parse(file, "toml/tests/example.toml");
fclose(file);
BOOST_TEST(toml::find<std::string>(data, "title") == "TOML Example");
const auto& owner = toml::find(data, "owner");
{
BOOST_TEST(toml::find<std::string>(owner, "name") == "Tom Preston-Werner");
BOOST_TEST(toml::find<std::string>(owner, "organization") == "GitHub");
BOOST_TEST(toml::find<std::string>(owner, "bio") ==
"GitHub Cofounder & CEO\nLikes tater tots and beer.");
BOOST_TEST(toml::find<toml::offset_datetime>(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_TEST(toml::find<std::string>(database, "server") == "192.168.1.1");
const std::vector<int> expected_ports{8001, 8001, 8002};
BOOST_CHECK(toml::find<std::vector<int>>(database, "ports") == expected_ports);
BOOST_TEST(toml::find<int >(database, "connection_max") == 5000);
BOOST_TEST(toml::find<bool>(database, "enabled") == true);
}
const auto& servers = toml::find(data, "servers");
{
toml::table alpha = toml::find<toml::table>(servers, "alpha");
BOOST_TEST(toml::get<std::string>(alpha.at("ip")) == "10.0.0.1");
BOOST_TEST(toml::get<std::string>(alpha.at("dc")) == "eqdc10");
toml::table beta = toml::find<toml::table>(servers, "beta");
BOOST_TEST(toml::get<std::string>(beta.at("ip")) == "10.0.0.2");
BOOST_TEST(toml::get<std::string>(beta.at("dc")) == "eqdc10");
BOOST_TEST(toml::get<std::string>(beta.at("country")) == "\xE4\xB8\xAD\xE5\x9B\xBD");
}
const auto& clients = toml::find(data, "clients");
{
toml::array clients_data = toml::find<toml::array>(clients, "data");
std::vector<std::string> expected_name{"gamma", "delta"};
BOOST_CHECK(toml::get<std::vector<std::string>>(clients_data.at(0)) == expected_name);
std::vector<int> expected_number{1, 2};
BOOST_CHECK(toml::get<std::vector<int>>(clients_data.at(1)) == expected_number);
std::vector<std::string> expected_hosts{"alpha", "omega"};
BOOST_CHECK(toml::find<std::vector<std::string>>(clients, "hosts") == expected_hosts);
}
std::vector<toml::table> products =
toml::find<std::vector<toml::table>>(data, "products");
{
BOOST_TEST(toml::get<std::string>(products.at(0).at("name")) ==
"Hammer");
BOOST_TEST(toml::get<std::int64_t>(products.at(0).at("sku")) ==
738594937);
BOOST_TEST(toml::get<std::string>(products.at(1).at("name")) ==
"Nail");
BOOST_TEST(toml::get<std::int64_t>(products.at(1).at("sku")) ==
284758393);
BOOST_TEST(toml::get<std::string>(products.at(1).at("color")) ==
"gray");
}
}
add parse() function
2017-05-12 11:49:47 +00:00
BOOST_AUTO_TEST_CASE(test_fruit)
{
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
const auto data = toml::parse(testinput("fruit.toml"));
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
const auto blah = toml::find<toml::array>(toml::find(data, "fruit"), "blah");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(blah.at(0), "name") == "apple");
BOOST_TEST(toml::find<std::string>(blah.at(1), "name") == "banana");
add parse() function
2017-05-12 11:49:47 +00:00
{
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
const auto physical = toml::find(blah.at(0), "physical");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(physical, "color") == "red");
BOOST_TEST(toml::find<std::string>(physical, "shape") == "round");
add parse() function
2017-05-12 11:49:47 +00:00
}
{
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
const auto physical = toml::find(blah.at(1), "physical");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(physical, "color") == "yellow");
BOOST_TEST(toml::find<std::string>(physical, "shape") == "bent");
add parse() function
2017-05-12 11:49:47 +00:00
}
}
fix array_of_table assignments
2017-05-12 13:28:49 +00:00
BOOST_AUTO_TEST_CASE(test_hard_example)
{
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
const auto data = toml::parse(testinput("hard_example.toml"));
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
const auto the = toml::find(data, "the");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(the, "test_string") ==
fix array_of_table assignments
2017-05-12 13:28:49 +00:00
"You'll hate me after this - #");
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
const auto hard = toml::find(the, "hard");
fix array_of_table assignments
2017-05-12 13:28:49 +00:00
const std::vector<std::string> expected_the_hard_test_array{"] ", " # "};
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
BOOST_CHECK(toml::find<std::vector<std::string>>(hard, "test_array") ==
fix array_of_table assignments
2017-05-12 13:28:49 +00:00
expected_the_hard_test_array);
const std::vector<std::string> expected_the_hard_test_array2{
"Test #11 ]proved that", "Experiment #9 was a success"};
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
BOOST_CHECK(toml::find<std::vector<std::string>>(hard, "test_array2") ==
fix array_of_table assignments
2017-05-12 13:28:49 +00:00
expected_the_hard_test_array2);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(hard, "another_test_string") ==
fix array_of_table assignments
2017-05-12 13:28:49 +00:00
" Same thing, but with a string #");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(hard, "harder_test_string") ==
fix array_of_table assignments
2017-05-12 13:28:49 +00:00
" And when \"'s are in the string, along with # \"");
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
const auto bit = toml::find(hard, "bit#");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(bit, "what?") ==
fix array_of_table assignments
2017-05-12 13:28:49 +00:00
"You don't think some user won't do that?");
const std::vector<std::string> expected_multi_line_array{"]"};
test: update retval of parse and related get/find
2019-06-03 12:44:47 +00:00
BOOST_CHECK(toml::find<std::vector<std::string>>(bit, "multi_line_array") ==
fix array_of_table assignments
2017-05-12 13:28:49 +00:00
expected_multi_line_array);
}
test: check preserve_comment keep it read
2019-06-17 16:25:43 +00:00
BOOST_AUTO_TEST_CASE(test_hard_example_comment)
{
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
const auto data = toml::parse<toml::preserve_comments>(testinput("hard_example.toml"));
test: check preserve_comment keep it read
2019-06-17 16:25:43 +00:00
const auto the = toml::find(data, "the");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(the, "test_string") ==
test: check preserve_comment keep it read
2019-06-17 16:25:43 +00:00
"You'll hate me after this - #");
const auto hard = toml::find(the, "hard");
const std::vector<std::string> expected_the_hard_test_array{"] ", " # "};
BOOST_CHECK(toml::find<std::vector<std::string>>(hard, "test_array") ==
expected_the_hard_test_array);
const std::vector<std::string> expected_the_hard_test_array2{
"Test #11 ]proved that", "Experiment #9 was a success"};
BOOST_CHECK(toml::find<std::vector<std::string>>(hard, "test_array2") ==
expected_the_hard_test_array2);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(hard, "another_test_string") ==
test: check preserve_comment keep it read
2019-06-17 16:25:43 +00:00
" Same thing, but with a string #");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(hard, "harder_test_string") ==
test: check preserve_comment keep it read
2019-06-17 16:25:43 +00:00
" And when \"'s are in the string, along with # \"");
const auto bit = toml::find(hard, "bit#");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(bit, "what?") ==
test: check preserve_comment keep it read
2019-06-17 16:25:43 +00:00
"You don't think some user won't do that?");
const std::vector<std::string> expected_multi_line_array{"]"};
BOOST_CHECK(toml::find<std::vector<std::string>>(bit, "multi_line_array") ==
expected_multi_line_array);
}
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
BOOST_AUTO_TEST_CASE(test_example_preserve_comment)
{
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
const auto data = toml::parse<toml::preserve_comments>(testinput("example.toml"));
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "title") == "TOML Example");
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
const auto& owner = toml::find(data, "owner");
{
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(owner, "name") == "Tom Preston-Werner");
BOOST_TEST(toml::find<std::string>(owner, "organization") == "GitHub");
BOOST_TEST(toml::find<std::string>(owner, "bio") ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
"GitHub Cofounder & CEO\nLikes tater tots and beer.");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<toml::offset_datetime>(owner, "dob") ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27),
toml::local_time(7, 32, 0), toml::time_offset(0, 0)));
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find(owner, "dob").comments().at(0) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
" First class dates? Why not?");
}
const auto& database = toml::find(data, "database");
{
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(database, "server") == "192.168.1.1");
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
const std::vector<int> expected_ports{8001, 8001, 8002};
BOOST_CHECK(toml::find<std::vector<int>>(database, "ports") == expected_ports);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<int >(database, "connection_max") == 5000);
BOOST_TEST(toml::find<bool>(database, "enabled") == true);
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
}
const auto& servers = toml::find(data, "servers");
{
const auto& alpha = toml::find(servers, "alpha");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(alpha.comments().at(0) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
" You can indent as you please. Tabs or spaces. TOML don't care.");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(alpha, "ip") == "10.0.0.1");
BOOST_TEST(toml::find<std::string>(alpha, "dc") == "eqdc10");
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
const auto& beta = toml::find(servers, "beta");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(beta, "ip") == "10.0.0.2");
BOOST_TEST(toml::find<std::string>(beta, "dc") == "eqdc10");
BOOST_TEST(toml::find<std::string>(beta, "country") ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
"\xE4\xB8\xAD\xE5\x9B\xBD");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find(beta, "country").comments().at(0) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
" This should be parsed as UTF-8");
}
const auto& clients = toml::find(data, "clients");
{
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find(clients, "data").comments().at(0) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
" just an update to make sure parsers support it");
toml::array clients_data = toml::find<toml::array>(clients, "data");
std::vector<std::string> expected_name{"gamma", "delta"};
BOOST_CHECK(toml::get<std::vector<std::string>>(clients_data.at(0)) ==
expected_name);
std::vector<int> expected_number{1, 2};
BOOST_CHECK(toml::get<std::vector<int>>(clients_data.at(1)) ==
expected_number);
std::vector<std::string> expected_hosts{"alpha", "omega"};
BOOST_CHECK(toml::find<std::vector<std::string>>(clients, "hosts") ==
expected_hosts);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find(clients, "hosts").comments().at(0) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
" Line breaks are OK when inside arrays");
}
std::vector<toml::table> products =
toml::find<std::vector<toml::table>>(data, "products");
{
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::string>(products.at(0).at("name")) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
"Hammer");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::int64_t>(products.at(0).at("sku")) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
738594937);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::string>(products.at(1).at("name")) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
"Nail");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::int64_t>(products.at(1).at("sku")) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
284758393);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::string>(products.at(1).at("color")) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
"gray");
}
}
BOOST_AUTO_TEST_CASE(test_example_preserve_stdmap_stddeque)
{
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
const auto data = toml::parse<toml::preserve_comments, std::map, std::deque>(
testinput("example.toml"));
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
static_assert(std::is_same<typename decltype(data)::table_type,
std::map<toml::key, typename std::remove_cv<decltype(data)>::type>
>::value, "");
static_assert(std::is_same<typename decltype(data)::array_type,
std::deque<typename std::remove_cv<decltype(data)>::type>
>::value, "");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "title") == "TOML Example");
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
const auto& owner = toml::find(data, "owner");
{
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(owner, "name") == "Tom Preston-Werner");
BOOST_TEST(toml::find<std::string>(owner, "organization") == "GitHub");
BOOST_TEST(toml::find<std::string>(owner, "bio") ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
"GitHub Cofounder & CEO\nLikes tater tots and beer.");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<toml::offset_datetime>(owner, "dob") ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27),
toml::local_time(7, 32, 0), toml::time_offset(0, 0)));
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find(owner, "dob").comments().at(0) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
" First class dates? Why not?");
}
const auto& database = toml::find(data, "database");
{
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(database, "server") == "192.168.1.1");
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
const std::vector<int> expected_ports{8001, 8001, 8002};
BOOST_CHECK(toml::find<std::vector<int>>(database, "ports") == expected_ports);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<int >(database, "connection_max") == 5000);
BOOST_TEST(toml::find<bool>(database, "enabled") == true);
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
}
const auto& servers = toml::find(data, "servers");
{
const auto& alpha = toml::find(servers, "alpha");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(alpha.comments().at(0) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
" You can indent as you please. Tabs or spaces. TOML don't care.");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(alpha, "ip") == "10.0.0.1");
BOOST_TEST(toml::find<std::string>(alpha, "dc") == "eqdc10");
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
const auto& beta = toml::find(servers, "beta");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(beta, "ip") == "10.0.0.2");
BOOST_TEST(toml::find<std::string>(beta, "dc") == "eqdc10");
BOOST_TEST(toml::find<std::string>(beta, "country") ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
"\xE4\xB8\xAD\xE5\x9B\xBD");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find(beta, "country").comments().at(0) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
" This should be parsed as UTF-8");
}
const auto& clients = toml::find(data, "clients");
{
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find(clients, "data").comments().at(0) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
" just an update to make sure parsers support it");
toml::array clients_data = toml::find<toml::array>(clients, "data");
std::vector<std::string> expected_name{"gamma", "delta"};
BOOST_CHECK(toml::get<std::vector<std::string>>(clients_data.at(0)) ==
expected_name);
std::vector<int> expected_number{1, 2};
BOOST_CHECK(toml::get<std::vector<int>>(clients_data.at(1)) ==
expected_number);
std::vector<std::string> expected_hosts{"alpha", "omega"};
BOOST_CHECK(toml::find<std::vector<std::string>>(clients, "hosts") ==
expected_hosts);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find(clients, "hosts").comments().at(0) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
" Line breaks are OK when inside arrays");
}
std::vector<toml::table> products =
toml::find<std::vector<toml::table>>(data, "products");
{
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::string>(products.at(0).at("name")) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
"Hammer");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::int64_t>(products.at(0).at("sku")) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
738594937);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::string>(products.at(1).at("name")) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
"Nail");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::int64_t>(products.at(1).at("sku")) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
284758393);
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::get<std::string>(products.at(1).at("color")) ==
refactor: exchange order of test section
2019-06-17 15:45:30 +00:00
"gray");
}
}
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
// ---------------------------------------------------------------------------
// after here, the test codes generate the content of a file.
BOOST_AUTO_TEST_CASE(test_file_with_BOM)
{
{
const std::string table(
"\xEF\xBB\xBF" // BOM
"key = \"value\"\n"
"[table]\n"
"key = \"value\"\n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss, "test_file_with_BOM.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
fix: open file as binary-mode #16 to avoid inconsistency between file size (obtained by tellg) and the size of the actual contents that would be read later
2019-02-13 10:18:09 +00:00
{
const std::string table(
"\xEF\xBB\xBF" // BOM
"key = \"value\"\n"
"[table]\n"
"key = \"value\"\n"
);
fix: add scope to the test case to flush
2019-02-13 10:26:52 +00:00
{
std::ofstream ofs("tmp.toml");
ofs << table;
}
fix: open file as binary-mode #16 to avoid inconsistency between file size (obtained by tellg) and the size of the actual contents that would be read later
2019-02-13 10:18:09 +00:00
const auto data = toml::parse("tmp.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
fix: open file as binary-mode #16 to avoid inconsistency between file size (obtained by tellg) and the size of the actual contents that would be read later
2019-02-13 10:18:09 +00:00
}
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
{
const std::string table(
"\xEF\xBB\xBF" // BOM
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\"\r\n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss, "test_file_with_BOM_CRLF.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
fix: open file as binary-mode #16 to avoid inconsistency between file size (obtained by tellg) and the size of the actual contents that would be read later
2019-02-13 10:18:09 +00:00
}
{
const std::string table(
"\xEF\xBB\xBF" // BOM
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\"\r\n"
);
fix: add scope to the test case to flush
2019-02-13 10:26:52 +00:00
{
fix: avoid auto-conversion while making test case
2019-02-13 10:51:54 +00:00
// with text-mode, "\n" is converted to "\r\n" and the resulting
// value will be "\r\r\n". To avoid the additional "\r", use binary
// mode.
std::ofstream ofs("tmp.toml", std::ios_base::binary);
refactor: streamsize is a signed integer
2019-06-20 14:59:54 +00:00
ofs.write(table.data(), static_cast<std::streamsize>(table.size()));
fix: add scope to the test case to flush
2019-02-13 10:26:52 +00:00
}
fix: open file as binary-mode #16 to avoid inconsistency between file size (obtained by tellg) and the size of the actual contents that would be read later
2019-02-13 10:18:09 +00:00
const auto data = toml::parse("tmp.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
}
BOOST_AUTO_TEST_CASE(test_file_without_newline_at_the_end_of_file)
{
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\""
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_file_without_newline_at_the_end_of_file.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\""
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_file_without_newline_at_the_end_of_file_CRLF.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\" # comment"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_file_without_newline_at_the_end_of_file_comment.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\" # comment"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_file_without_newline_at_the_end_of_file_comment.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\" \t"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_file_without_newline_at_the_end_of_file_ws.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\" \t"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_file_without_newline_at_the_end_of_file_ws.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
}
BOOST_AUTO_TEST_CASE(test_files_end_with_comment)
{
// comment w/o newline
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\"\n"
"# comment"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_comment.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\"\n"
"# comment\n"
"# one more comment"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_comment.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
// comment w/ newline
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\"\n"
"# comment\n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_comment.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\"\n"
"# comment\n"
"# one more comment\n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_comment.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
// CRLF version
{
const std::string table(
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\"\r\n"
"# comment"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_comment.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\"\r\n"
"# comment\r\n"
"# one more comment"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_comment.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\"\r\n"
"# comment\r\n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_comment.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\"\r\n"
"# comment\r\n"
"# one more comment\r\n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_comment.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
}
BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
{
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\"\n"
"\n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_newline.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\"\n"
"\n"
"\n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_newline.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
// with whitespaces
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\"\n"
" \n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_newline.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\"\n"
" \n"
" \n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_newline.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\"\n"
"\n"
" \n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_newline.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\"\n"
" \n"
"\n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_newline.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
// with whitespaces but no newline
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\"\n"
" "
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_newline.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
test: add test for no-eof-newline cases
2020-09-14 07:39:05 +00:00
// without newline
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\"\n"
"a = 0"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_newline.toml");
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
}
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
// CRLF
{
const std::string table(
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\"\r\n"
"\r\n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_newline.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\"\r\n"
"\r\n"
"\r\n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_newline.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
// with whitespaces
{
const std::string table(
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\"\r\n"
" \r\n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_newline.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\"\r\n"
"\r\n"
" \r\n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_newline.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\"\r\n"
" \r\n"
"\r\n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_newline.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\"\r\n"
" \r\n"
" \r\n"
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_newline.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
{
const std::string table(
"key = \"value\"\r\n"
"[table]\r\n"
"key = \"value\"\r\n"
" "
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_with_newline.toml");
test: add basic_value type to serialization tests
2019-06-21 06:22:46 +00:00
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
add test cases for the end-of-file problems
2018-12-24 07:02:32 +00:00
}
}
test: add test for custom basic_value type
2019-06-15 11:25:19 +00:00
test: add test_file_ends_without_lf
2021-12-10 14:46:14 +00:00
BOOST_AUTO_TEST_CASE(test_file_ends_without_lf)
{
{
const std::string table(
"key = \"value\"\n"
"[table]\n"
"key = \"value\""
);
std::istringstream iss(table);
const auto data = toml::parse(iss,
"test_files_end_without_lf.toml");
BOOST_TEST(toml::find<std::string>(data, "key") == "value");
BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
}
}
test: check each overload compiles
2020-08-05 11:29:07 +00:00
BOOST_AUTO_TEST_CASE(test_parse_function_compiles)
{
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
const auto c = [](std::string& s) -> const std::string& { return s; };
/*mutable*/ std::string example = testinput("example.toml");
test: check each overload compiles
2020-08-05 11:29:07 +00:00
// toml::parse("");
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
using result_type = decltype(toml::parse("string literal"));
test: check each overload compiles
2020-08-05 11:29:07 +00:00
test: use array for char* forgot to delete
2020-08-05 11:43:48 +00:00
BOOST_TEST_MESSAGE("string_literal");
test: check each overload compiles
2020-08-05 11:29:07 +00:00
// toml::parse(const char*);
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
const result_type cstring = toml::parse(example.c_str());
test: check each overload compiles
2020-08-05 11:29:07 +00:00
test: use array for char* forgot to delete
2020-08-05 11:43:48 +00:00
BOOST_TEST_MESSAGE("const char*");
test: check each overload compiles
2020-08-05 11:29:07 +00:00
// toml::parse(char*);
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
const result_type char_ptr = toml::parse(&example.front());
test: use array for char* forgot to delete
2020-08-05 11:43:48 +00:00
BOOST_TEST_MESSAGE("char*");
test: check each overload compiles
2020-08-05 11:29:07 +00:00
// toml::parse(const std::string&);
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
const result_type string = toml::parse(c(example));
test: check each overload compiles
2020-08-05 11:29:07 +00:00
// toml::parse(std::string&);
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
const result_type string_mutref = toml::parse(example);
test: check each overload compiles
2020-08-05 11:29:07 +00:00
// toml::parse(std::string&&);
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
const result_type string_rref = toml::parse(std::move(example));
test: check each overload compiles
2020-08-05 11:29:07 +00:00
test: use array for char* forgot to delete
2020-08-05 11:43:48 +00:00
BOOST_TEST_MESSAGE("strings");
test: check each overload compiles
2020-08-05 11:29:07 +00:00
#ifdef TOML11_HAS_STD_FILESYSTEM
More flexible https://github.com/toml-lang/toml handling Instead of unconditionally attempting to clone from a fixed location (GitHub) during the build / test process, honor the following two configuration variables: TOML11_LANGSPEC_GIT_REPOSITORY Can be set to override the URL from which the repository is cloned. This allows using a local mirror, including file:// URLs for working offline or reducing network traffic. TOML11_LANGSPEC_SOURCE_DIR Can be set to configure the location at which the repository is expected. If it already exists no download will be attempted. This allows avoiding the additional git-clone(1) altogether and use an existing directory as-is. This offers two new possibilities: (1) The same checkout can be reused for building multiple configurations (e.g. Debug versus Release) saving a little bit of time and disk space. (2) Experimental changes can easily be applied to the local source tree without having them destroyed by the build process. In order for this flexible location to work, the unit tests which attempt to read files from the repository had to be adjusted. They now honor an environment variable TOMLDIR which can be set to point to an alternate root directory. All defaults are set such that the previous behavior is maintained. Instead of introducing the TOMLDIR environment variable, an alternative solution would have been to set the WORKING_DIRECTORY of the tests to the TOML11_LANGSPEC_SOURCE_DIR and leave the relative paths in these tests hard-coded. Alas, some tests also expect that they can /write/ into the current working directory which isn't desirable if it is potentially pointing outside the build tree. I personally prefer to mount the source directory read-only and build in a fast tempfs, so this would e a problem. To be perfectly honest, I don't quite understand why these tests need to write to the file system in the first place, though. It seems to me that refactoring them to serialize to a std::ostrstream instead of a std::ofstream would not only simplify but also speed up the unit tests and avoid file system problems. But there might have been a hidden reason why actually using the real file system was considered necessary for these tests, so I didn't went ahead with that change yet.
2022-09-16 09:51:32 +00:00
const std::filesystem::path fname_path(example.begin(), example.end());
const result_type filesystem_path = toml::parse(fname_path);
test: use array for char* forgot to delete
2020-08-05 11:43:48 +00:00
BOOST_TEST_MESSAGE("path");
test: check each overload compiles
2020-08-05 11:29:07 +00:00
#endif
}
feat: Add a parse(FILE *) interface The fstream classes are notorious for their non-existent error handling. This adds a C-style fILE * IO (fopen(), etc.) alternative interface, so that if a user needs reliable error handling, they can use that, albeit more inconvenient, but more robust approach.
2022-06-30 11:53:32 +00:00
BOOST_AUTO_TEST_CASE(test_parse_nonexistent_file)
{
fix: Improve error handling of ifstream a bit Set the exceptions mask so that exceptions are thrown when an I/O error occurs. Also throw the same exception type when the opening fails.
2022-09-08 14:58:56 +00:00
BOOST_CHECK_THROW(toml::parse("nonexistent.toml"), std::ios_base::failure);
feat: Add a parse(FILE *) interface The fstream classes are notorious for their non-existent error handling. This adds a C-style fILE * IO (fopen(), etc.) alternative interface, so that if a user needs reliable error handling, they can use that, albeit more inconvenient, but more robust approach.
2022-06-30 11:53:32 +00:00
}
Reference in New Issue Copy Permalink