From 1a2fa6d53a815017fd15d2f8d602504735601eaa Mon Sep 17 00:00:00 2001 From: ToruNiina Date: Tue, 4 Dec 2018 20:30:21 +0900 Subject: [PATCH] add test for lexers --- tests/CMakeLists.txt | 6 ++ tests/test_lex_aux.hpp | 42 ++++++++++++++ tests/test_lex_boolean.cpp | 23 ++++++++ tests/test_lex_datetime.cpp | 57 +++++++++++++++++++ tests/test_lex_floating.cpp | 84 +++++++++++++++++++++++++++ tests/test_lex_integer.cpp | 101 +++++++++++++++++++++++++++++++++ tests/test_lex_key_comment.cpp | 40 +++++++++++++ tests/test_lex_string.cpp | 78 +++++++++++++++++++++++++ 8 files changed, 431 insertions(+) create mode 100644 tests/test_lex_aux.hpp create mode 100644 tests/test_lex_boolean.cpp create mode 100644 tests/test_lex_datetime.cpp create mode 100644 tests/test_lex_floating.cpp create mode 100644 tests/test_lex_integer.cpp create mode 100644 tests/test_lex_key_comment.cpp create mode 100644 tests/test_lex_string.cpp diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index e2056a1..b6a0e14 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,4 +1,10 @@ set(TEST_NAMES + test_lex_boolean + test_lex_integer + test_lex_floating + test_lex_datetime + test_lex_string + test_lex_key_comment test_traits test_utility test_result diff --git a/tests/test_lex_aux.hpp b/tests/test_lex_aux.hpp new file mode 100644 index 0000000..ba1cea5 --- /dev/null +++ b/tests/test_lex_aux.hpp @@ -0,0 +1,42 @@ +#include +#include +#include +#include +#include + +#define TOML11_TEST_LEX_ACCEPT(lxr, tkn, expct) \ +do { \ + const std::string token (tkn); \ + const std::string expected(expct); \ + toml::detail::location loc(token); \ + const auto result = lxr::invoke(loc); \ + BOOST_CHECK(result.is_ok()); \ + if(result.is_ok()){ \ + const auto matched = result.unwrap().str(); \ + std::cerr << "matched -> "; \ + std::for_each(matched.begin(), matched.end(), [](const char c) { \ + std::cerr << std::setw(2) << std::hex << std::setfill('0'); \ + std::cerr << "0x" << static_cast(c) << ", "; \ + return; \ + }); \ + std::cerr << std::endl; \ + const auto region = result.unwrap(); \ + BOOST_CHECK_EQUAL(region.str(), expected); \ + BOOST_CHECK_EQUAL(region.str().size(), expected.size()); \ + BOOST_CHECK_EQUAL(std::distance(loc.begin(), loc.iter()), region.size()); \ + } else { \ + std::cerr << "lexer " << lxr::pattern() << " failed with input `"; \ + std::cerr << token << "`. expected `" << expected << "`\n"; \ + std::cerr << "reason: " << result.unwrap_err() << '\n'; \ + } \ +} while(false); \ +/**/ + +#define TOML11_TEST_LEX_REJECT(lxr, tkn) \ +do { \ + const std::string token (tkn); \ + toml::detail::location loc(token); \ + const auto result = lxr::invoke(loc); \ + BOOST_CHECK(result.is_err()); \ + BOOST_CHECK(loc.begin() == loc.iter()); \ +} while(false); /**/ diff --git a/tests/test_lex_boolean.cpp b/tests/test_lex_boolean.cpp new file mode 100644 index 0000000..c2e43a8 --- /dev/null +++ b/tests/test_lex_boolean.cpp @@ -0,0 +1,23 @@ +#define BOOST_TEST_MODULE "test_lex_boolean" +#include +#include +#include "test_lex_aux.hpp" + +using namespace toml; +using namespace detail; + +BOOST_AUTO_TEST_CASE(test_correct) +{ + TOML11_TEST_LEX_ACCEPT(lex_boolean, "true", "true"); + TOML11_TEST_LEX_ACCEPT(lex_boolean, "false", "false"); + TOML11_TEST_LEX_ACCEPT(lex_boolean, "true # trailing", "true"); + TOML11_TEST_LEX_ACCEPT(lex_boolean, "false # trailing", "false"); +} + +BOOST_AUTO_TEST_CASE(test_invalid) +{ + TOML11_TEST_LEX_REJECT(lex_boolean, "TRUE"); + TOML11_TEST_LEX_REJECT(lex_boolean, "FALSE"); + TOML11_TEST_LEX_REJECT(lex_boolean, "True"); + TOML11_TEST_LEX_REJECT(lex_boolean, "False"); +} diff --git a/tests/test_lex_datetime.cpp b/tests/test_lex_datetime.cpp new file mode 100644 index 0000000..a790eeb --- /dev/null +++ b/tests/test_lex_datetime.cpp @@ -0,0 +1,57 @@ +#define BOOST_TEST_MODULE "test_lex_datetime" +#include +#include +#include "test_lex_aux.hpp" + +using namespace toml; +using namespace detail; + +BOOST_AUTO_TEST_CASE(test_offset_datetime) +{ + TOML11_TEST_LEX_ACCEPT(lex_offset_date_time, + "1979-05-27T07:32:00Z", + "1979-05-27T07:32:00Z"); + TOML11_TEST_LEX_ACCEPT(lex_offset_date_time, + "1979-05-27T07:32:00-07:00", + "1979-05-27T07:32:00-07:00"); + TOML11_TEST_LEX_ACCEPT(lex_offset_date_time, + "1979-05-27T07:32:00.999999-07:00", + "1979-05-27T07:32:00.999999-07:00"); + + TOML11_TEST_LEX_ACCEPT(lex_offset_date_time, + "1979-05-27 07:32:00Z", + "1979-05-27 07:32:00Z"); + TOML11_TEST_LEX_ACCEPT(lex_offset_date_time, + "1979-05-27 07:32:00-07:00", + "1979-05-27 07:32:00-07:00"); + TOML11_TEST_LEX_ACCEPT(lex_offset_date_time, + "1979-05-27 07:32:00.999999-07:00", + "1979-05-27 07:32:00.999999-07:00"); +} + +BOOST_AUTO_TEST_CASE(test_local_datetime) +{ + TOML11_TEST_LEX_ACCEPT(lex_local_date_time, + "1979-05-27T07:32:00", + "1979-05-27T07:32:00"); + TOML11_TEST_LEX_ACCEPT(lex_local_date_time, + "1979-05-27T07:32:00.999999", + "1979-05-27T07:32:00.999999"); + + TOML11_TEST_LEX_ACCEPT(lex_local_date_time, + "1979-05-27 07:32:00", + "1979-05-27 07:32:00"); + TOML11_TEST_LEX_ACCEPT(lex_local_date_time, + "1979-05-27 07:32:00.999999", + "1979-05-27 07:32:00.999999"); +} + +BOOST_AUTO_TEST_CASE(test_local_date) +{ + TOML11_TEST_LEX_ACCEPT(lex_local_date, "1979-05-27", "1979-05-27"); +} +BOOST_AUTO_TEST_CASE(test_local_time) +{ + TOML11_TEST_LEX_ACCEPT(lex_local_time, "07:32:00", "07:32:00"); + TOML11_TEST_LEX_ACCEPT(lex_local_time, "07:32:00.999999", "07:32:00.999999"); +} diff --git a/tests/test_lex_floating.cpp b/tests/test_lex_floating.cpp new file mode 100644 index 0000000..79ce157 --- /dev/null +++ b/tests/test_lex_floating.cpp @@ -0,0 +1,84 @@ +#define BOOST_TEST_MODULE "test_lex_floating" +#include +#include +#include +#include "test_lex_aux.hpp" + +using namespace toml; +using namespace detail; + +BOOST_AUTO_TEST_CASE(test_fractional_valid) +{ + TOML11_TEST_LEX_ACCEPT(lex_float, "1.0", "1.0" ); + TOML11_TEST_LEX_ACCEPT(lex_float, "0.1", "0.1" ); + TOML11_TEST_LEX_ACCEPT(lex_float, "0.001", "0.001" ); + TOML11_TEST_LEX_ACCEPT(lex_float, "0.100", "0.100" ); + TOML11_TEST_LEX_ACCEPT(lex_float, "+3.14", "+3.14" ); + TOML11_TEST_LEX_ACCEPT(lex_float, "-3.14", "-3.14" ); + TOML11_TEST_LEX_ACCEPT(lex_float, "3.1415_9265_3589", "3.1415_9265_3589" ); + TOML11_TEST_LEX_ACCEPT(lex_float, "+3.1415_9265_3589", "+3.1415_9265_3589"); + TOML11_TEST_LEX_ACCEPT(lex_float, "-3.1415_9265_3589", "-3.1415_9265_3589"); + TOML11_TEST_LEX_ACCEPT(lex_float, "123_456.789", "123_456.789" ); + TOML11_TEST_LEX_ACCEPT(lex_float, "+123_456.789", "+123_456.789" ); + TOML11_TEST_LEX_ACCEPT(lex_float, "-123_456.789", "-123_456.789" ); +} + +BOOST_AUTO_TEST_CASE(test_fractional_invalid) +{ + TOML11_TEST_LEX_REJECT(lex_float, "0."); + TOML11_TEST_LEX_REJECT(lex_float, ".0"); + TOML11_TEST_LEX_REJECT(lex_float, "01.0"); + TOML11_TEST_LEX_REJECT(lex_float, "3,14"); + TOML11_TEST_LEX_REJECT(lex_float, "+-1.0"); + TOML11_TEST_LEX_REJECT(lex_float, "1._0"); +} + +BOOST_AUTO_TEST_CASE(test_exponential_valid) +{ + TOML11_TEST_LEX_ACCEPT(lex_float, "1e10", "1e10"); + TOML11_TEST_LEX_ACCEPT(lex_float, "1e+10", "1e+10"); + TOML11_TEST_LEX_ACCEPT(lex_float, "1e-10", "1e-10"); + TOML11_TEST_LEX_ACCEPT(lex_float, "+1e10", "+1e10"); + TOML11_TEST_LEX_ACCEPT(lex_float, "+1e+10", "+1e+10"); + TOML11_TEST_LEX_ACCEPT(lex_float, "+1e-10", "+1e-10"); + TOML11_TEST_LEX_ACCEPT(lex_float, "-1e10", "-1e10"); + TOML11_TEST_LEX_ACCEPT(lex_float, "-1e+10", "-1e+10"); + TOML11_TEST_LEX_ACCEPT(lex_float, "-1e-10", "-1e-10"); + TOML11_TEST_LEX_ACCEPT(lex_float, "123e-10", "123e-10"); + TOML11_TEST_LEX_ACCEPT(lex_float, "1E10", "1E10"); + TOML11_TEST_LEX_ACCEPT(lex_float, "1E+10", "1E+10"); + TOML11_TEST_LEX_ACCEPT(lex_float, "1E-10", "1E-10"); + TOML11_TEST_LEX_ACCEPT(lex_float, "123E-10", "123E-10"); + TOML11_TEST_LEX_ACCEPT(lex_float, "1_2_3E-10", "1_2_3E-10"); + TOML11_TEST_LEX_ACCEPT(lex_float, "1_2_3E-1_0", "1_2_3E-1_0"); +} + +BOOST_AUTO_TEST_CASE(test_exponential_invalid) +{ + TOML11_TEST_LEX_ACCEPT(lex_float, "1e1E0", "1e1"); + TOML11_TEST_LEX_ACCEPT(lex_float, "1E1e0", "1E1"); +} + +BOOST_AUTO_TEST_CASE(test_both_valid) +{ + TOML11_TEST_LEX_ACCEPT(lex_float, "6.02e23", "6.02e23"); + TOML11_TEST_LEX_ACCEPT(lex_float, "6.02e+23", "6.02e+23"); + TOML11_TEST_LEX_ACCEPT(lex_float, "1.112_650_06e-17", "1.112_650_06e-17"); +} + +BOOST_AUTO_TEST_CASE(test_both_invalid) +{ + TOML11_TEST_LEX_ACCEPT(lex_float, "1e1.0", "1e1"); + TOML11_TEST_LEX_REJECT(lex_float, "01e1.0"); +} + +BOOST_AUTO_TEST_CASE(test_special_floating_point) +{ + TOML11_TEST_LEX_ACCEPT(lex_float, "inf", "inf"); + TOML11_TEST_LEX_ACCEPT(lex_float, "+inf", "+inf"); + TOML11_TEST_LEX_ACCEPT(lex_float, "-inf", "-inf"); + + TOML11_TEST_LEX_ACCEPT(lex_float, "nan", "nan"); + TOML11_TEST_LEX_ACCEPT(lex_float, "+nan", "+nan"); + TOML11_TEST_LEX_ACCEPT(lex_float, "-nan", "-nan"); +} diff --git a/tests/test_lex_integer.cpp b/tests/test_lex_integer.cpp new file mode 100644 index 0000000..bb6dbb7 --- /dev/null +++ b/tests/test_lex_integer.cpp @@ -0,0 +1,101 @@ +#define BOOST_TEST_MODULE "test_lex_integer" +#include +#include +#include "test_lex_aux.hpp" + +using namespace toml; +using namespace detail; + +BOOST_AUTO_TEST_CASE(test_decimal_correct) +{ + TOML11_TEST_LEX_ACCEPT(lex_integer, "1234", "1234" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "+1234", "+1234" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "-1234", "-1234" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0", "0" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "1_2_3_4", "1_2_3_4" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "+1_2_3_4", "+1_2_3_4" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "-1_2_3_4", "-1_2_3_4" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "123_456_789", "123_456_789"); +} + +BOOST_AUTO_TEST_CASE(test_decimal_invalid) +{ + TOML11_TEST_LEX_ACCEPT(lex_integer, "123+45", "123"); + TOML11_TEST_LEX_ACCEPT(lex_integer, "123-45", "123"); + TOML11_TEST_LEX_ACCEPT(lex_integer, "01234", "0"); + TOML11_TEST_LEX_ACCEPT(lex_integer, "123__45", "123"); + + TOML11_TEST_LEX_REJECT(lex_integer, "_1234"); +} + +BOOST_AUTO_TEST_CASE(test_hex_correct) +{ + TOML11_TEST_LEX_ACCEPT(lex_integer, "0xDEADBEEF", "0xDEADBEEF" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0xdeadbeef", "0xdeadbeef" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0xDEADbeef", "0xDEADbeef" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0xDEAD_BEEF", "0xDEAD_BEEF"); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0xdead_beef", "0xdead_beef"); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0xdead_BEEF", "0xdead_BEEF"); + + TOML11_TEST_LEX_ACCEPT(lex_integer, "0xFF", "0xFF" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0x00FF", "0x00FF" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0x0000FF", "0x0000FF"); +} + +BOOST_AUTO_TEST_CASE(test_hex_invalid) +{ + TOML11_TEST_LEX_ACCEPT(lex_integer, "0xAPPLE", "0xA"); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0xDEAD+BEEF", "0xDEAD"); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0xDEAD__BEEF", "0xDEAD"); + + TOML11_TEST_LEX_REJECT(lex_hex_int, "0x_DEADBEEF"); + TOML11_TEST_LEX_REJECT(lex_hex_int, "0x+DEADBEEF"); + TOML11_TEST_LEX_REJECT(lex_hex_int, "-0xFF" ); + TOML11_TEST_LEX_REJECT(lex_hex_int, "-0x00FF" ); + + TOML11_TEST_LEX_ACCEPT(lex_integer, "0x_DEADBEEF", "0" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0x+DEADBEEF", "0" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "-0xFF" , "-0" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "-0x00FF" , "-0" ); +} + +BOOST_AUTO_TEST_CASE(test_oct_correct) +{ + TOML11_TEST_LEX_ACCEPT(lex_integer, "0o777", "0o777" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0o7_7_7", "0o7_7_7"); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0o007", "0o007" ); + +} + +BOOST_AUTO_TEST_CASE(test_oct_invalid) +{ + TOML11_TEST_LEX_ACCEPT(lex_integer, "0o77+7", "0o77"); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0o1__0", "0o1"); + + TOML11_TEST_LEX_REJECT(lex_oct_int, "0o800" ); + TOML11_TEST_LEX_REJECT(lex_oct_int, "-0o777"); + TOML11_TEST_LEX_REJECT(lex_oct_int, "0o+777"); + TOML11_TEST_LEX_REJECT(lex_oct_int, "0o_10" ); + + TOML11_TEST_LEX_ACCEPT(lex_integer, "0o800", "0"); + TOML11_TEST_LEX_ACCEPT(lex_integer, "-0o777", "-0"); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0o+777", "0"); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0o_10", "0"); +} + +BOOST_AUTO_TEST_CASE(test_bin_correct) +{ + TOML11_TEST_LEX_ACCEPT(lex_integer, "0b10000", "0b10000" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0b010000", "0b010000" ); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0b01_00_00", "0b01_00_00"); + TOML11_TEST_LEX_ACCEPT(lex_integer, "0b111111", "0b111111" ); +} + +BOOST_AUTO_TEST_CASE(test_bin_invalid) +{ + TOML11_TEST_LEX_ACCEPT(lex_bin_int, "0b11__11", "0b11"); + TOML11_TEST_LEX_ACCEPT(lex_bin_int, "0b11+11" , "0b11"); + + TOML11_TEST_LEX_REJECT(lex_bin_int, "-0b10000"); + TOML11_TEST_LEX_REJECT(lex_bin_int, "0b_1111" ); +} diff --git a/tests/test_lex_key_comment.cpp b/tests/test_lex_key_comment.cpp new file mode 100644 index 0000000..c64c72f --- /dev/null +++ b/tests/test_lex_key_comment.cpp @@ -0,0 +1,40 @@ +#define BOOST_TEST_MODULE "lex_key_comment_test" +#include +#include +#include "test_lex_aux.hpp" + +using namespace toml; +using namespace detail; + +BOOST_AUTO_TEST_CASE(test_bare_key) +{ + TOML11_TEST_LEX_ACCEPT(lex_key, "barekey", "barekey"); + TOML11_TEST_LEX_ACCEPT(lex_key, "bare-key", "bare-key"); + TOML11_TEST_LEX_ACCEPT(lex_key, "bare_key", "bare_key"); + TOML11_TEST_LEX_ACCEPT(lex_key, "1234", "1234"); +} + +BOOST_AUTO_TEST_CASE(test_quoted_key) +{ + TOML11_TEST_LEX_ACCEPT(lex_key, "\"127.0.0.1\"", "\"127.0.0.1\""); + TOML11_TEST_LEX_ACCEPT(lex_key, "\"character encoding\"", "\"character encoding\""); + TOML11_TEST_LEX_ACCEPT(lex_key, "\"ʎǝʞ\"", "\"ʎǝʞ\""); + TOML11_TEST_LEX_ACCEPT(lex_key, "'key2'", "'key2'"); + TOML11_TEST_LEX_ACCEPT(lex_key, "'quoted \"value\"'", "'quoted \"value\"'"); +} + +BOOST_AUTO_TEST_CASE(test_dotted_key) +{ + TOML11_TEST_LEX_ACCEPT(lex_key, "physical.color", "physical.color"); + TOML11_TEST_LEX_ACCEPT(lex_key, "physical.shape", "physical.shape"); + TOML11_TEST_LEX_ACCEPT(lex_key, "x.y.z.w", "x.y.z.w"); + TOML11_TEST_LEX_ACCEPT(lex_key, "site.\"google.com\"", "site.\"google.com\""); +} + +BOOST_AUTO_TEST_CASE(test_comment) +{ + TOML11_TEST_LEX_ACCEPT(lex_comment, "# hoge", "# hoge"); + TOML11_TEST_LEX_ACCEPT(lex_comment, "# \n", "# "); + TOML11_TEST_LEX_ACCEPT(lex_comment, "# \r\n", "# "); + TOML11_TEST_LEX_ACCEPT(lex_comment, "# # \n", "# # "); +} diff --git a/tests/test_lex_string.cpp b/tests/test_lex_string.cpp new file mode 100644 index 0000000..4c36b66 --- /dev/null +++ b/tests/test_lex_string.cpp @@ -0,0 +1,78 @@ +#define BOOST_TEST_MODULE "test_lex_string" +#include +#include +#include "test_lex_aux.hpp" + +using namespace toml; +using namespace detail; + +BOOST_AUTO_TEST_CASE(test_string) +{ + TOML11_TEST_LEX_ACCEPT(lex_string, + "\"The quick brown fox jumps over the lazy dog\"", + "\"The quick brown fox jumps over the lazy dog\""); + TOML11_TEST_LEX_ACCEPT(lex_string, + "\'The quick brown fox jumps over the lazy dog\'", + "\'The quick brown fox jumps over the lazy dog\'"); + TOML11_TEST_LEX_ACCEPT(lex_ml_basic_string, + "\"\"\"The quick brown fox \\\njumps over the lazy dog\"\"\"", + "\"\"\"The quick brown fox \\\njumps over the lazy dog\"\"\""); + TOML11_TEST_LEX_ACCEPT(lex_ml_literal_string, + "'''The quick brown fox \njumps over the lazy dog'''", + "'''The quick brown fox \njumps over the lazy dog'''"); +} + +BOOST_AUTO_TEST_CASE(test_basic_string) +{ + TOML11_TEST_LEX_ACCEPT(lex_string, + "\"GitHub Cofounder & CEO\\nLikes tater tots and beer.\"", + "\"GitHub Cofounder & CEO\\nLikes tater tots and beer.\""); + TOML11_TEST_LEX_ACCEPT(lex_string, + "\"192.168.1.1\"", + "\"192.168.1.1\""); + TOML11_TEST_LEX_ACCEPT(lex_string, + "\"中国\"", + "\"中国\""); + TOML11_TEST_LEX_ACCEPT(lex_string, + "\"You'll hate me after this - #\"", + "\"You'll hate me after this - #\""); + TOML11_TEST_LEX_ACCEPT(lex_string, + "\" And when \\\"'s are in the string, along with # \\\"\"", + "\" And when \\\"'s are in the string, along with # \\\"\""); +} + +BOOST_AUTO_TEST_CASE(test_ml_basic_string) +{ + TOML11_TEST_LEX_ACCEPT(lex_string, + "\"\"\"\nThe quick brown \\\n\n fox jumps over \\\n the lazy dog.\"\"\"", + "\"\"\"\nThe quick brown \\\n\n fox jumps over \\\n the lazy dog.\"\"\""); + TOML11_TEST_LEX_ACCEPT(lex_string, + "\"\"\"\\\n The quick brown \\\n\n fox jumps over \\\n the lazy dog.\\\n \"\"\"", + "\"\"\"\\\n The quick brown \\\n\n fox jumps over \\\n the lazy dog.\\\n \"\"\""); +} + +BOOST_AUTO_TEST_CASE(test_literal_string) +{ + TOML11_TEST_LEX_ACCEPT(lex_string, + "'C:\\Users\\nodejs\\templates'", + "'C:\\Users\\nodejs\\templates'"); + TOML11_TEST_LEX_ACCEPT(lex_string, + "'\\\\ServerX\\admin$\\system32\\'", + "'\\\\ServerX\\admin$\\system32\\'"); + TOML11_TEST_LEX_ACCEPT(lex_string, + "'Tom \"Dubs\" Preston-Werner'", + "'Tom \"Dubs\" Preston-Werner'"); + TOML11_TEST_LEX_ACCEPT(lex_string, + "'<\\i\\c*\\s*>'", + "'<\\i\\c*\\s*>'"); +} + +BOOST_AUTO_TEST_CASE(test_ml_literal_string) +{ + TOML11_TEST_LEX_ACCEPT(lex_string, + "'''I [dw]on't need \\d{2} apples'''", + "'''I [dw]on't need \\d{2} apples'''"); + TOML11_TEST_LEX_ACCEPT(lex_string, + "'''\nThe first newline is\ntrimmed in raw strings.\n All other whitespace\n is preserved.\n'''", + "'''\nThe first newline is\ntrimmed in raw strings.\n All other whitespace\n is preserved.\n'''"); +}