diff --git a/include/boost/parser/detail/case_fold.hpp b/include/boost/parser/detail/case_fold.hpp new file mode 100644 index 00000000..6c4c5e33 --- /dev/null +++ b/include/boost/parser/detail/case_fold.hpp @@ -0,0 +1,104 @@ +#ifndef BOOST_PARSER_DETAIL_CASE_FOLD_HPP +#define BOOST_PARSER_DETAIL_CASE_FOLD_HPP + +#include +#include + +#include + + +namespace boost::parser::detail { + + inline std::optional do_short_mapping( + short_mapping_range const * first, + short_mapping_range const * last, + char32_t cp, + char32_t * out) + { + auto it = std::lower_bound( + first, + last, + cp, + [](short_mapping_range const & range, char32_t cp) { + return range.cp_first_ < cp; + }); + if (it != first) { + auto const prev = it - 1; + if (prev->cp_first_ <= cp && cp < prev->cp_last_) + it = prev; + } + if (it != last && it->cp_first_ <= cp && cp < it->cp_last_) { + auto const offset = cp - it->cp_first_; + if (offset % it->stride_ == 0) { + *out++ = + single_mapping_cps[it->first_idx_ + offset / it->stride_]; + return out; + } + } + + return std::nullopt; + } + + inline char32_t * case_fold(char32_t cp, char32_t * out) + { + // One-byte fast path. + if (cp < 0x100) { + // ASCII letter fast path. + if (0x41 <= cp && cp < 0x5a) { + *out++ = cp + 0x20; + return out; + } else if (cp == 0x00DF) { + // The lone multi-mapping below 0x100. + *out++ = 0x0073; + *out++ = 0x0073; + return out; + } else { + // Skip [0x41, 0x5a), handled above. + auto const first = std::begin(mapping_ranges) + 1; + // 7th entry starts with 0x100. + auto const last = std::begin(mapping_ranges) + 7; + if (auto out_opt = do_short_mapping(first, last, cp, out)) + return *out_opt; + } + *out++ = cp; + return out; + } + + // Single-cp-mapping path (next most common case). + { + auto const first = std::begin(mapping_ranges); + auto const last = std::end(mapping_ranges); + if (auto out_opt = do_short_mapping(first, last, cp, out)) + return *out_opt; + } + + // Multi-cp mapping path. + { + auto const last = std::end(long_mappings); + auto const it = std::lower_bound( + std::begin(long_mappings), + last, + cp, + [](long_mapping const & mapping, char32_t cp) { + return mapping.cp_ < cp; + }); + if (it != last && it->cp_ == cp) { +#if BOOST_PARSER_USE_CONCEPTS + return std::ranges::copy(it->mapping_, null_sentinel, out); +#else + return std::copy( + it->mapping_, + std::find( + std::begin(it->mapping_), std::end(it->mapping_), 0), + out); +#endif + } + } + + *out++ = cp; + return out; + } + +} + +#endif diff --git a/include/boost/parser/detail/case_fold_data_generated.hpp b/include/boost/parser/detail/case_fold_data_generated.hpp new file mode 100644 index 00000000..cec7648a --- /dev/null +++ b/include/boost/parser/detail/case_fold_data_generated.hpp @@ -0,0 +1,533 @@ +// Copyright (c) 2024 T. Zachary Laine +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Warning: This header is auto-generated (see misc/generate_case_fold_data.py). +// The lack of include guards is intentional. + +namespace boost::parser::detail { + + +struct short_mapping_range { + char32_t cp_first_; + char32_t cp_last_; + uint16_t stride_; + uint16_t first_idx_; +}; +inline constexpr int longest_mapping = 3; +struct long_mapping { + char32_t cp_; + char32_t mapping_[longest_mapping + 1]; +}; +inline constexpr long_mapping long_mappings[104] = { + {0x00DF, {0x0073, 0x0073 , 0}}, + {0x0130, {0x0069, 0x0307 , 0}}, + {0x0149, {0x02BC, 0x006E , 0}}, + {0x01F0, {0x006A, 0x030C , 0}}, + {0x0390, {0x03B9, 0x0308, 0x0301 , 0}}, + {0x03B0, {0x03C5, 0x0308, 0x0301 , 0}}, + {0x0587, {0x0565, 0x0582 , 0}}, + {0x1E96, {0x0068, 0x0331 , 0}}, + {0x1E97, {0x0074, 0x0308 , 0}}, + {0x1E98, {0x0077, 0x030A , 0}}, + {0x1E99, {0x0079, 0x030A , 0}}, + {0x1E9A, {0x0061, 0x02BE , 0}}, + {0x1E9E, {0x0073, 0x0073 , 0}}, + {0x1F50, {0x03C5, 0x0313 , 0}}, + {0x1F52, {0x03C5, 0x0313, 0x0300 , 0}}, + {0x1F54, {0x03C5, 0x0313, 0x0301 , 0}}, + {0x1F56, {0x03C5, 0x0313, 0x0342 , 0}}, + {0x1F80, {0x1F00, 0x03B9 , 0}}, + {0x1F81, {0x1F01, 0x03B9 , 0}}, + {0x1F82, {0x1F02, 0x03B9 , 0}}, + {0x1F83, {0x1F03, 0x03B9 , 0}}, + {0x1F84, {0x1F04, 0x03B9 , 0}}, + {0x1F85, {0x1F05, 0x03B9 , 0}}, + {0x1F86, {0x1F06, 0x03B9 , 0}}, + {0x1F87, {0x1F07, 0x03B9 , 0}}, + {0x1F88, {0x1F00, 0x03B9 , 0}}, + {0x1F89, {0x1F01, 0x03B9 , 0}}, + {0x1F8A, {0x1F02, 0x03B9 , 0}}, + {0x1F8B, {0x1F03, 0x03B9 , 0}}, + {0x1F8C, {0x1F04, 0x03B9 , 0}}, + {0x1F8D, {0x1F05, 0x03B9 , 0}}, + {0x1F8E, {0x1F06, 0x03B9 , 0}}, + {0x1F8F, {0x1F07, 0x03B9 , 0}}, + {0x1F90, {0x1F20, 0x03B9 , 0}}, + {0x1F91, {0x1F21, 0x03B9 , 0}}, + {0x1F92, {0x1F22, 0x03B9 , 0}}, + {0x1F93, {0x1F23, 0x03B9 , 0}}, + {0x1F94, {0x1F24, 0x03B9 , 0}}, + {0x1F95, {0x1F25, 0x03B9 , 0}}, + {0x1F96, {0x1F26, 0x03B9 , 0}}, + {0x1F97, {0x1F27, 0x03B9 , 0}}, + {0x1F98, {0x1F20, 0x03B9 , 0}}, + {0x1F99, {0x1F21, 0x03B9 , 0}}, + {0x1F9A, {0x1F22, 0x03B9 , 0}}, + {0x1F9B, {0x1F23, 0x03B9 , 0}}, + {0x1F9C, {0x1F24, 0x03B9 , 0}}, + {0x1F9D, {0x1F25, 0x03B9 , 0}}, + {0x1F9E, {0x1F26, 0x03B9 , 0}}, + {0x1F9F, {0x1F27, 0x03B9 , 0}}, + {0x1FA0, {0x1F60, 0x03B9 , 0}}, + {0x1FA1, {0x1F61, 0x03B9 , 0}}, + {0x1FA2, {0x1F62, 0x03B9 , 0}}, + {0x1FA3, {0x1F63, 0x03B9 , 0}}, + {0x1FA4, {0x1F64, 0x03B9 , 0}}, + {0x1FA5, {0x1F65, 0x03B9 , 0}}, + {0x1FA6, {0x1F66, 0x03B9 , 0}}, + {0x1FA7, {0x1F67, 0x03B9 , 0}}, + {0x1FA8, {0x1F60, 0x03B9 , 0}}, + {0x1FA9, {0x1F61, 0x03B9 , 0}}, + {0x1FAA, {0x1F62, 0x03B9 , 0}}, + {0x1FAB, {0x1F63, 0x03B9 , 0}}, + {0x1FAC, {0x1F64, 0x03B9 , 0}}, + {0x1FAD, {0x1F65, 0x03B9 , 0}}, + {0x1FAE, {0x1F66, 0x03B9 , 0}}, + {0x1FAF, {0x1F67, 0x03B9 , 0}}, + {0x1FB2, {0x1F70, 0x03B9 , 0}}, + {0x1FB3, {0x03B1, 0x03B9 , 0}}, + {0x1FB4, {0x03AC, 0x03B9 , 0}}, + {0x1FB6, {0x03B1, 0x0342 , 0}}, + {0x1FB7, {0x03B1, 0x0342, 0x03B9 , 0}}, + {0x1FBC, {0x03B1, 0x03B9 , 0}}, + {0x1FC2, {0x1F74, 0x03B9 , 0}}, + {0x1FC3, {0x03B7, 0x03B9 , 0}}, + {0x1FC4, {0x03AE, 0x03B9 , 0}}, + {0x1FC6, {0x03B7, 0x0342 , 0}}, + {0x1FC7, {0x03B7, 0x0342, 0x03B9 , 0}}, + {0x1FCC, {0x03B7, 0x03B9 , 0}}, + {0x1FD2, {0x03B9, 0x0308, 0x0300 , 0}}, + {0x1FD3, {0x03B9, 0x0308, 0x0301 , 0}}, + {0x1FD6, {0x03B9, 0x0342 , 0}}, + {0x1FD7, {0x03B9, 0x0308, 0x0342 , 0}}, + {0x1FE2, {0x03C5, 0x0308, 0x0300 , 0}}, + {0x1FE3, {0x03C5, 0x0308, 0x0301 , 0}}, + {0x1FE4, {0x03C1, 0x0313 , 0}}, + {0x1FE6, {0x03C5, 0x0342 , 0}}, + {0x1FE7, {0x03C5, 0x0308, 0x0342 , 0}}, + {0x1FF2, {0x1F7C, 0x03B9 , 0}}, + {0x1FF3, {0x03C9, 0x03B9 , 0}}, + {0x1FF4, {0x03CE, 0x03B9 , 0}}, + {0x1FF6, {0x03C9, 0x0342 , 0}}, + {0x1FF7, {0x03C9, 0x0342, 0x03B9 , 0}}, + {0x1FFC, {0x03C9, 0x03B9 , 0}}, + {0xFB00, {0x0066, 0x0066 , 0}}, + {0xFB01, {0x0066, 0x0069 , 0}}, + {0xFB02, {0x0066, 0x006C , 0}}, + {0xFB03, {0x0066, 0x0066, 0x0069 , 0}}, + {0xFB04, {0x0066, 0x0066, 0x006C , 0}}, + {0xFB05, {0x0073, 0x0074 , 0}}, + {0xFB06, {0x0073, 0x0074 , 0}}, + {0xFB13, {0x0574, 0x0576 , 0}}, + {0xFB14, {0x0574, 0x0565 , 0}}, + {0xFB15, {0x0574, 0x056B , 0}}, + {0xFB16, {0x057E, 0x0576 , 0}}, + {0xFB17, {0x0574, 0x056D , 0}}, +}; +inline constexpr short_mapping_range mapping_ranges[220] = { + {0x0041, 0x005A, 1, 0}, + {0x005A, 0x00B5, 91, 25}, + {0x00B5, 0x00C0, 11, 26}, + {0x00C0, 0x00D6, 1, 27}, + {0x00D6, 0x00D8, 2, 49}, + {0x00D8, 0x00DE, 1, 50}, + {0x00DE, 0x0100, 34, 56}, + {0x0100, 0x012E, 2, 57}, + {0x012E, 0x0132, 4, 80}, + {0x0132, 0x0136, 2, 81}, + {0x0136, 0x0139, 3, 83}, + {0x0139, 0x0147, 2, 84}, + {0x0147, 0x014A, 3, 91}, + {0x014A, 0x0178, 2, 92}, + {0x0178, 0x0179, 1, 115}, + {0x0179, 0x0181, 2, 116}, + {0x0181, 0x0182, 1, 120}, + {0x0182, 0x0186, 2, 121}, + {0x0186, 0x0187, 1, 123}, + {0x0187, 0x0189, 2, 124}, + {0x0189, 0x018B, 1, 125}, + {0x018B, 0x018E, 3, 127}, + {0x018E, 0x0191, 1, 128}, + {0x0191, 0x0193, 2, 131}, + {0x0193, 0x0194, 1, 132}, + {0x0194, 0x0196, 2, 133}, + {0x0196, 0x0198, 1, 134}, + {0x0198, 0x019C, 4, 136}, + {0x019C, 0x019D, 1, 137}, + {0x019D, 0x019F, 2, 138}, + {0x019F, 0x01A0, 1, 139}, + {0x01A0, 0x01A6, 2, 140}, + {0x01A6, 0x01A7, 1, 143}, + {0x01A7, 0x01A9, 2, 144}, + {0x01A9, 0x01AC, 3, 145}, + {0x01AC, 0x01AE, 2, 146}, + {0x01AE, 0x01AF, 1, 147}, + {0x01AF, 0x01B1, 2, 148}, + {0x01B1, 0x01B3, 1, 149}, + {0x01B3, 0x01B7, 2, 151}, + {0x01B7, 0x01B8, 1, 153}, + {0x01B8, 0x01BC, 4, 154}, + {0x01BC, 0x01C4, 8, 155}, + {0x01C4, 0x01C5, 1, 156}, + {0x01C5, 0x01C7, 2, 157}, + {0x01C7, 0x01C8, 1, 158}, + {0x01C8, 0x01CA, 2, 159}, + {0x01CA, 0x01CB, 1, 160}, + {0x01CB, 0x01DB, 2, 161}, + {0x01DB, 0x01DE, 3, 169}, + {0x01DE, 0x01EE, 2, 170}, + {0x01EE, 0x01F1, 3, 178}, + {0x01F1, 0x01F2, 1, 179}, + {0x01F2, 0x01F6, 2, 180}, + {0x01F6, 0x01F8, 1, 182}, + {0x01F8, 0x0232, 2, 184}, + {0x0232, 0x023A, 8, 213}, + {0x023A, 0x023B, 1, 214}, + {0x023B, 0x023D, 2, 215}, + {0x023D, 0x023E, 1, 216}, + {0x023E, 0x0241, 3, 217}, + {0x0241, 0x0243, 2, 218}, + {0x0243, 0x0246, 1, 219}, + {0x0246, 0x024E, 2, 222}, + {0x024E, 0x0345, 247, 226}, + {0x0345, 0x0370, 43, 227}, + {0x0370, 0x0372, 2, 228}, + {0x0372, 0x0376, 4, 229}, + {0x0376, 0x037F, 9, 230}, + {0x037F, 0x0386, 7, 231}, + {0x0386, 0x0388, 2, 232}, + {0x0388, 0x038A, 1, 233}, + {0x038A, 0x038E, 2, 235}, + {0x038E, 0x038F, 1, 237}, + {0x038F, 0x0391, 2, 238}, + {0x0391, 0x03A1, 1, 239}, + {0x03A1, 0x03A3, 2, 255}, + {0x03A3, 0x03AB, 1, 256}, + {0x03AB, 0x03C2, 23, 264}, + {0x03C2, 0x03CF, 13, 265}, + {0x03CF, 0x03D1, 1, 266}, + {0x03D1, 0x03D5, 4, 268}, + {0x03D5, 0x03D6, 1, 269}, + {0x03D6, 0x03F0, 2, 270}, + {0x03F0, 0x03F1, 1, 283}, + {0x03F1, 0x03F4, 3, 284}, + {0x03F4, 0x03F5, 1, 285}, + {0x03F5, 0x03F9, 2, 286}, + {0x03F9, 0x03FA, 1, 288}, + {0x03FA, 0x03FD, 3, 289}, + {0x03FD, 0x042F, 1, 290}, + {0x042F, 0x0460, 49, 340}, + {0x0460, 0x0480, 2, 341}, + {0x0480, 0x048A, 10, 357}, + {0x048A, 0x04C0, 2, 358}, + {0x04C0, 0x04C1, 1, 385}, + {0x04C1, 0x04CD, 2, 386}, + {0x04CD, 0x04D0, 3, 392}, + {0x04D0, 0x052E, 2, 393}, + {0x052E, 0x0531, 3, 440}, + {0x0531, 0x0556, 1, 441}, + {0x0556, 0x10A0, 2890, 478}, + {0x10A0, 0x10C5, 1, 479}, + {0x10C5, 0x10C7, 2, 516}, + {0x10C7, 0x10CD, 6, 517}, + {0x10CD, 0x13F8, 811, 518}, + {0x13F8, 0x13FD, 1, 519}, + {0x13FD, 0x1C80, 2179, 524}, + {0x1C80, 0x1C88, 1, 525}, + {0x1C88, 0x1C90, 8, 533}, + {0x1C90, 0x1CBA, 1, 534}, + {0x1CBA, 0x1CBD, 3, 576}, + {0x1CBD, 0x1CBF, 1, 577}, + {0x1CBF, 0x1E00, 321, 579}, + {0x1E00, 0x1E94, 2, 580}, + {0x1E94, 0x1E9B, 7, 654}, + {0x1E9B, 0x1EA0, 5, 655}, + {0x1EA0, 0x1EFE, 2, 656}, + {0x1EFE, 0x1F08, 10, 703}, + {0x1F08, 0x1F0F, 1, 704}, + {0x1F0F, 0x1F18, 9, 711}, + {0x1F18, 0x1F1D, 1, 712}, + {0x1F1D, 0x1F28, 11, 717}, + {0x1F28, 0x1F2F, 1, 718}, + {0x1F2F, 0x1F38, 9, 725}, + {0x1F38, 0x1F3F, 1, 726}, + {0x1F3F, 0x1F48, 9, 733}, + {0x1F48, 0x1F4D, 1, 734}, + {0x1F4D, 0x1F59, 12, 739}, + {0x1F59, 0x1F5F, 2, 740}, + {0x1F5F, 0x1F68, 9, 743}, + {0x1F68, 0x1F6F, 1, 744}, + {0x1F6F, 0x1FB8, 73, 751}, + {0x1FB8, 0x1FBB, 1, 752}, + {0x1FBB, 0x1FBE, 3, 755}, + {0x1FBE, 0x1FC8, 10, 756}, + {0x1FC8, 0x1FCB, 1, 757}, + {0x1FCB, 0x1FD8, 13, 760}, + {0x1FD8, 0x1FDB, 1, 761}, + {0x1FDB, 0x1FE8, 13, 764}, + {0x1FE8, 0x1FEC, 1, 765}, + {0x1FEC, 0x1FF8, 12, 769}, + {0x1FF8, 0x1FFB, 1, 770}, + {0x1FFB, 0x2126, 299, 773}, + {0x2126, 0x212A, 4, 774}, + {0x212A, 0x212B, 1, 775}, + {0x212B, 0x2132, 7, 776}, + {0x2132, 0x2160, 46, 777}, + {0x2160, 0x216F, 1, 778}, + {0x216F, 0x2183, 20, 793}, + {0x2183, 0x24B6, 819, 794}, + {0x24B6, 0x24CF, 1, 795}, + {0x24CF, 0x2C00, 1841, 820}, + {0x2C00, 0x2C2F, 1, 821}, + {0x2C2F, 0x2C60, 49, 868}, + {0x2C60, 0x2C62, 2, 869}, + {0x2C62, 0x2C64, 1, 870}, + {0x2C64, 0x2C67, 3, 872}, + {0x2C67, 0x2C6D, 2, 873}, + {0x2C6D, 0x2C70, 1, 876}, + {0x2C70, 0x2C72, 2, 879}, + {0x2C72, 0x2C75, 3, 880}, + {0x2C75, 0x2C7E, 9, 881}, + {0x2C7E, 0x2C80, 1, 882}, + {0x2C80, 0x2CE2, 2, 884}, + {0x2CE2, 0x2CEB, 9, 933}, + {0x2CEB, 0x2CED, 2, 934}, + {0x2CED, 0x2CF2, 5, 935}, + {0x2CF2, 0xA640, 31054, 936}, + {0xA640, 0xA66C, 2, 937}, + {0xA66C, 0xA680, 20, 959}, + {0xA680, 0xA69A, 2, 960}, + {0xA69A, 0xA722, 136, 973}, + {0xA722, 0xA72E, 2, 974}, + {0xA72E, 0xA732, 4, 980}, + {0xA732, 0xA76E, 2, 981}, + {0xA76E, 0xA779, 11, 1011}, + {0xA779, 0xA77D, 2, 1012}, + {0xA77D, 0xA77E, 1, 1014}, + {0xA77E, 0xA786, 2, 1015}, + {0xA786, 0xA78B, 5, 1019}, + {0xA78B, 0xA78D, 2, 1020}, + {0xA78D, 0xA790, 3, 1021}, + {0xA790, 0xA792, 2, 1022}, + {0xA792, 0xA796, 4, 1023}, + {0xA796, 0xA7AA, 2, 1024}, + {0xA7AA, 0xA7AE, 1, 1034}, + {0xA7AE, 0xA7B0, 2, 1038}, + {0xA7B0, 0xA7B4, 1, 1039}, + {0xA7B4, 0xA7C4, 2, 1043}, + {0xA7C4, 0xA7C7, 1, 1051}, + {0xA7C7, 0xA7C9, 2, 1054}, + {0xA7C9, 0xA7D0, 7, 1055}, + {0xA7D0, 0xA7D6, 6, 1056}, + {0xA7D6, 0xA7D8, 2, 1057}, + {0xA7D8, 0xA7F5, 29, 1058}, + {0xA7F5, 0xAB70, 891, 1059}, + {0xAB70, 0xABBF, 1, 1060}, + {0xABBF, 0xFF21, 21346, 1139}, + {0xFF21, 0xFF3A, 1, 1140}, + {0xFF3A, 0x10400, 1222, 1165}, + {0x10400, 0x10427, 1, 1166}, + {0x10427, 0x104B0, 137, 1205}, + {0x104B0, 0x104D3, 1, 1206}, + {0x104D3, 0x10570, 157, 1241}, + {0x10570, 0x1057A, 1, 1242}, + {0x1057A, 0x1057C, 2, 1252}, + {0x1057C, 0x1058A, 1, 1253}, + {0x1058A, 0x1058C, 2, 1267}, + {0x1058C, 0x10592, 1, 1268}, + {0x10592, 0x10594, 2, 1274}, + {0x10594, 0x10595, 1, 1275}, + {0x10595, 0x10C80, 1771, 1276}, + {0x10C80, 0x10CB2, 1, 1277}, + {0x10CB2, 0x118A0, 3054, 1327}, + {0x118A0, 0x118BF, 1, 1328}, + {0x118BF, 0x16E40, 21889, 1359}, + {0x16E40, 0x16E5F, 1, 1360}, + {0x16E5F, 0x1E900, 31393, 1391}, + {0x1E900, 0x1E921 + 1, 1, 1392}, +}; +inline constexpr char32_t single_mapping_cps[1426] = { + 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, + 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, 0x0070, + 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, + 0x0079, 0x007A, 0x03BC, 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, + 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, + 0x00ED, 0x00EE, 0x00EF, 0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, + 0x00F5, 0x00F6, 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, + 0x00FE, 0x0101, 0x0103, 0x0105, 0x0107, 0x0109, 0x010B, 0x010D, + 0x010F, 0x0111, 0x0113, 0x0115, 0x0117, 0x0119, 0x011B, 0x011D, + 0x011F, 0x0121, 0x0123, 0x0125, 0x0127, 0x0129, 0x012B, 0x012D, + 0x012F, 0x0133, 0x0135, 0x0137, 0x013A, 0x013C, 0x013E, 0x0140, + 0x0142, 0x0144, 0x0146, 0x0148, 0x014B, 0x014D, 0x014F, 0x0151, + 0x0153, 0x0155, 0x0157, 0x0159, 0x015B, 0x015D, 0x015F, 0x0161, + 0x0163, 0x0165, 0x0167, 0x0169, 0x016B, 0x016D, 0x016F, 0x0171, + 0x0173, 0x0175, 0x0177, 0x00FF, 0x017A, 0x017C, 0x017E, 0x0073, + 0x0253, 0x0183, 0x0185, 0x0254, 0x0188, 0x0256, 0x0257, 0x018C, + 0x01DD, 0x0259, 0x025B, 0x0192, 0x0260, 0x0263, 0x0269, 0x0268, + 0x0199, 0x026F, 0x0272, 0x0275, 0x01A1, 0x01A3, 0x01A5, 0x0280, + 0x01A8, 0x0283, 0x01AD, 0x0288, 0x01B0, 0x028A, 0x028B, 0x01B4, + 0x01B6, 0x0292, 0x01B9, 0x01BD, 0x01C6, 0x01C6, 0x01C9, 0x01C9, + 0x01CC, 0x01CC, 0x01CE, 0x01D0, 0x01D2, 0x01D4, 0x01D6, 0x01D8, + 0x01DA, 0x01DC, 0x01DF, 0x01E1, 0x01E3, 0x01E5, 0x01E7, 0x01E9, + 0x01EB, 0x01ED, 0x01EF, 0x01F3, 0x01F3, 0x01F5, 0x0195, 0x01BF, + 0x01F9, 0x01FB, 0x01FD, 0x01FF, 0x0201, 0x0203, 0x0205, 0x0207, + 0x0209, 0x020B, 0x020D, 0x020F, 0x0211, 0x0213, 0x0215, 0x0217, + 0x0219, 0x021B, 0x021D, 0x021F, 0x019E, 0x0223, 0x0225, 0x0227, + 0x0229, 0x022B, 0x022D, 0x022F, 0x0231, 0x0233, 0x2C65, 0x023C, + 0x019A, 0x2C66, 0x0242, 0x0180, 0x0289, 0x028C, 0x0247, 0x0249, + 0x024B, 0x024D, 0x024F, 0x03B9, 0x0371, 0x0373, 0x0377, 0x03F3, + 0x03AC, 0x03AD, 0x03AE, 0x03AF, 0x03CC, 0x03CD, 0x03CE, 0x03B1, + 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8, 0x03B9, + 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0, 0x03C1, + 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9, 0x03CA, + 0x03CB, 0x03C3, 0x03D7, 0x03B2, 0x03B8, 0x03C6, 0x03C0, 0x03D9, + 0x03DB, 0x03DD, 0x03DF, 0x03E1, 0x03E3, 0x03E5, 0x03E7, 0x03E9, + 0x03EB, 0x03ED, 0x03EF, 0x03BA, 0x03C1, 0x03B8, 0x03B5, 0x03F8, + 0x03F2, 0x03FB, 0x037B, 0x037C, 0x037D, 0x0450, 0x0451, 0x0452, + 0x0453, 0x0454, 0x0455, 0x0456, 0x0457, 0x0458, 0x0459, 0x045A, + 0x045B, 0x045C, 0x045D, 0x045E, 0x045F, 0x0430, 0x0431, 0x0432, + 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, + 0x043B, 0x043C, 0x043D, 0x043E, 0x043F, 0x0440, 0x0441, 0x0442, + 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, + 0x044B, 0x044C, 0x044D, 0x044E, 0x044F, 0x0461, 0x0463, 0x0465, + 0x0467, 0x0469, 0x046B, 0x046D, 0x046F, 0x0471, 0x0473, 0x0475, + 0x0477, 0x0479, 0x047B, 0x047D, 0x047F, 0x0481, 0x048B, 0x048D, + 0x048F, 0x0491, 0x0493, 0x0495, 0x0497, 0x0499, 0x049B, 0x049D, + 0x049F, 0x04A1, 0x04A3, 0x04A5, 0x04A7, 0x04A9, 0x04AB, 0x04AD, + 0x04AF, 0x04B1, 0x04B3, 0x04B5, 0x04B7, 0x04B9, 0x04BB, 0x04BD, + 0x04BF, 0x04CF, 0x04C2, 0x04C4, 0x04C6, 0x04C8, 0x04CA, 0x04CC, + 0x04CE, 0x04D1, 0x04D3, 0x04D5, 0x04D7, 0x04D9, 0x04DB, 0x04DD, + 0x04DF, 0x04E1, 0x04E3, 0x04E5, 0x04E7, 0x04E9, 0x04EB, 0x04ED, + 0x04EF, 0x04F1, 0x04F3, 0x04F5, 0x04F7, 0x04F9, 0x04FB, 0x04FD, + 0x04FF, 0x0501, 0x0503, 0x0505, 0x0507, 0x0509, 0x050B, 0x050D, + 0x050F, 0x0511, 0x0513, 0x0515, 0x0517, 0x0519, 0x051B, 0x051D, + 0x051F, 0x0521, 0x0523, 0x0525, 0x0527, 0x0529, 0x052B, 0x052D, + 0x052F, 0x0561, 0x0562, 0x0563, 0x0564, 0x0565, 0x0566, 0x0567, + 0x0568, 0x0569, 0x056A, 0x056B, 0x056C, 0x056D, 0x056E, 0x056F, + 0x0570, 0x0571, 0x0572, 0x0573, 0x0574, 0x0575, 0x0576, 0x0577, + 0x0578, 0x0579, 0x057A, 0x057B, 0x057C, 0x057D, 0x057E, 0x057F, + 0x0580, 0x0581, 0x0582, 0x0583, 0x0584, 0x0585, 0x0586, 0x2D00, + 0x2D01, 0x2D02, 0x2D03, 0x2D04, 0x2D05, 0x2D06, 0x2D07, 0x2D08, + 0x2D09, 0x2D0A, 0x2D0B, 0x2D0C, 0x2D0D, 0x2D0E, 0x2D0F, 0x2D10, + 0x2D11, 0x2D12, 0x2D13, 0x2D14, 0x2D15, 0x2D16, 0x2D17, 0x2D18, + 0x2D19, 0x2D1A, 0x2D1B, 0x2D1C, 0x2D1D, 0x2D1E, 0x2D1F, 0x2D20, + 0x2D21, 0x2D22, 0x2D23, 0x2D24, 0x2D25, 0x2D27, 0x2D2D, 0x13F0, + 0x13F1, 0x13F2, 0x13F3, 0x13F4, 0x13F5, 0x0432, 0x0434, 0x043E, + 0x0441, 0x0442, 0x0442, 0x044A, 0x0463, 0xA64B, 0x10D0, 0x10D1, + 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10D7, 0x10D8, 0x10D9, + 0x10DA, 0x10DB, 0x10DC, 0x10DD, 0x10DE, 0x10DF, 0x10E0, 0x10E1, + 0x10E2, 0x10E3, 0x10E4, 0x10E5, 0x10E6, 0x10E7, 0x10E8, 0x10E9, + 0x10EA, 0x10EB, 0x10EC, 0x10ED, 0x10EE, 0x10EF, 0x10F0, 0x10F1, + 0x10F2, 0x10F3, 0x10F4, 0x10F5, 0x10F6, 0x10F7, 0x10F8, 0x10F9, + 0x10FA, 0x10FD, 0x10FE, 0x10FF, 0x1E01, 0x1E03, 0x1E05, 0x1E07, + 0x1E09, 0x1E0B, 0x1E0D, 0x1E0F, 0x1E11, 0x1E13, 0x1E15, 0x1E17, + 0x1E19, 0x1E1B, 0x1E1D, 0x1E1F, 0x1E21, 0x1E23, 0x1E25, 0x1E27, + 0x1E29, 0x1E2B, 0x1E2D, 0x1E2F, 0x1E31, 0x1E33, 0x1E35, 0x1E37, + 0x1E39, 0x1E3B, 0x1E3D, 0x1E3F, 0x1E41, 0x1E43, 0x1E45, 0x1E47, + 0x1E49, 0x1E4B, 0x1E4D, 0x1E4F, 0x1E51, 0x1E53, 0x1E55, 0x1E57, + 0x1E59, 0x1E5B, 0x1E5D, 0x1E5F, 0x1E61, 0x1E63, 0x1E65, 0x1E67, + 0x1E69, 0x1E6B, 0x1E6D, 0x1E6F, 0x1E71, 0x1E73, 0x1E75, 0x1E77, + 0x1E79, 0x1E7B, 0x1E7D, 0x1E7F, 0x1E81, 0x1E83, 0x1E85, 0x1E87, + 0x1E89, 0x1E8B, 0x1E8D, 0x1E8F, 0x1E91, 0x1E93, 0x1E95, 0x1E61, + 0x1EA1, 0x1EA3, 0x1EA5, 0x1EA7, 0x1EA9, 0x1EAB, 0x1EAD, 0x1EAF, + 0x1EB1, 0x1EB3, 0x1EB5, 0x1EB7, 0x1EB9, 0x1EBB, 0x1EBD, 0x1EBF, + 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1EC9, 0x1ECB, 0x1ECD, 0x1ECF, + 0x1ED1, 0x1ED3, 0x1ED5, 0x1ED7, 0x1ED9, 0x1EDB, 0x1EDD, 0x1EDF, + 0x1EE1, 0x1EE3, 0x1EE5, 0x1EE7, 0x1EE9, 0x1EEB, 0x1EED, 0x1EEF, + 0x1EF1, 0x1EF3, 0x1EF5, 0x1EF7, 0x1EF9, 0x1EFB, 0x1EFD, 0x1EFF, + 0x1F00, 0x1F01, 0x1F02, 0x1F03, 0x1F04, 0x1F05, 0x1F06, 0x1F07, + 0x1F10, 0x1F11, 0x1F12, 0x1F13, 0x1F14, 0x1F15, 0x1F20, 0x1F21, + 0x1F22, 0x1F23, 0x1F24, 0x1F25, 0x1F26, 0x1F27, 0x1F30, 0x1F31, + 0x1F32, 0x1F33, 0x1F34, 0x1F35, 0x1F36, 0x1F37, 0x1F40, 0x1F41, + 0x1F42, 0x1F43, 0x1F44, 0x1F45, 0x1F51, 0x1F53, 0x1F55, 0x1F57, + 0x1F60, 0x1F61, 0x1F62, 0x1F63, 0x1F64, 0x1F65, 0x1F66, 0x1F67, + 0x1FB0, 0x1FB1, 0x1F70, 0x1F71, 0x03B9, 0x1F72, 0x1F73, 0x1F74, + 0x1F75, 0x1FD0, 0x1FD1, 0x1F76, 0x1F77, 0x1FE0, 0x1FE1, 0x1F7A, + 0x1F7B, 0x1FE5, 0x1F78, 0x1F79, 0x1F7C, 0x1F7D, 0x03C9, 0x006B, + 0x00E5, 0x214E, 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, + 0x2176, 0x2177, 0x2178, 0x2179, 0x217A, 0x217B, 0x217C, 0x217D, + 0x217E, 0x217F, 0x2184, 0x24D0, 0x24D1, 0x24D2, 0x24D3, 0x24D4, + 0x24D5, 0x24D6, 0x24D7, 0x24D8, 0x24D9, 0x24DA, 0x24DB, 0x24DC, + 0x24DD, 0x24DE, 0x24DF, 0x24E0, 0x24E1, 0x24E2, 0x24E3, 0x24E4, + 0x24E5, 0x24E6, 0x24E7, 0x24E8, 0x24E9, 0x2C30, 0x2C31, 0x2C32, + 0x2C33, 0x2C34, 0x2C35, 0x2C36, 0x2C37, 0x2C38, 0x2C39, 0x2C3A, + 0x2C3B, 0x2C3C, 0x2C3D, 0x2C3E, 0x2C3F, 0x2C40, 0x2C41, 0x2C42, + 0x2C43, 0x2C44, 0x2C45, 0x2C46, 0x2C47, 0x2C48, 0x2C49, 0x2C4A, + 0x2C4B, 0x2C4C, 0x2C4D, 0x2C4E, 0x2C4F, 0x2C50, 0x2C51, 0x2C52, + 0x2C53, 0x2C54, 0x2C55, 0x2C56, 0x2C57, 0x2C58, 0x2C59, 0x2C5A, + 0x2C5B, 0x2C5C, 0x2C5D, 0x2C5E, 0x2C5F, 0x2C61, 0x026B, 0x1D7D, + 0x027D, 0x2C68, 0x2C6A, 0x2C6C, 0x0251, 0x0271, 0x0250, 0x0252, + 0x2C73, 0x2C76, 0x023F, 0x0240, 0x2C81, 0x2C83, 0x2C85, 0x2C87, + 0x2C89, 0x2C8B, 0x2C8D, 0x2C8F, 0x2C91, 0x2C93, 0x2C95, 0x2C97, + 0x2C99, 0x2C9B, 0x2C9D, 0x2C9F, 0x2CA1, 0x2CA3, 0x2CA5, 0x2CA7, + 0x2CA9, 0x2CAB, 0x2CAD, 0x2CAF, 0x2CB1, 0x2CB3, 0x2CB5, 0x2CB7, + 0x2CB9, 0x2CBB, 0x2CBD, 0x2CBF, 0x2CC1, 0x2CC3, 0x2CC5, 0x2CC7, + 0x2CC9, 0x2CCB, 0x2CCD, 0x2CCF, 0x2CD1, 0x2CD3, 0x2CD5, 0x2CD7, + 0x2CD9, 0x2CDB, 0x2CDD, 0x2CDF, 0x2CE1, 0x2CE3, 0x2CEC, 0x2CEE, + 0x2CF3, 0xA641, 0xA643, 0xA645, 0xA647, 0xA649, 0xA64B, 0xA64D, + 0xA64F, 0xA651, 0xA653, 0xA655, 0xA657, 0xA659, 0xA65B, 0xA65D, + 0xA65F, 0xA661, 0xA663, 0xA665, 0xA667, 0xA669, 0xA66B, 0xA66D, + 0xA681, 0xA683, 0xA685, 0xA687, 0xA689, 0xA68B, 0xA68D, 0xA68F, + 0xA691, 0xA693, 0xA695, 0xA697, 0xA699, 0xA69B, 0xA723, 0xA725, + 0xA727, 0xA729, 0xA72B, 0xA72D, 0xA72F, 0xA733, 0xA735, 0xA737, + 0xA739, 0xA73B, 0xA73D, 0xA73F, 0xA741, 0xA743, 0xA745, 0xA747, + 0xA749, 0xA74B, 0xA74D, 0xA74F, 0xA751, 0xA753, 0xA755, 0xA757, + 0xA759, 0xA75B, 0xA75D, 0xA75F, 0xA761, 0xA763, 0xA765, 0xA767, + 0xA769, 0xA76B, 0xA76D, 0xA76F, 0xA77A, 0xA77C, 0x1D79, 0xA77F, + 0xA781, 0xA783, 0xA785, 0xA787, 0xA78C, 0x0265, 0xA791, 0xA793, + 0xA797, 0xA799, 0xA79B, 0xA79D, 0xA79F, 0xA7A1, 0xA7A3, 0xA7A5, + 0xA7A7, 0xA7A9, 0x0266, 0x025C, 0x0261, 0x026C, 0x026A, 0x029E, + 0x0287, 0x029D, 0xAB53, 0xA7B5, 0xA7B7, 0xA7B9, 0xA7BB, 0xA7BD, + 0xA7BF, 0xA7C1, 0xA7C3, 0xA794, 0x0282, 0x1D8E, 0xA7C8, 0xA7CA, + 0xA7D1, 0xA7D7, 0xA7D9, 0xA7F6, 0x13A0, 0x13A1, 0x13A2, 0x13A3, + 0x13A4, 0x13A5, 0x13A6, 0x13A7, 0x13A8, 0x13A9, 0x13AA, 0x13AB, + 0x13AC, 0x13AD, 0x13AE, 0x13AF, 0x13B0, 0x13B1, 0x13B2, 0x13B3, + 0x13B4, 0x13B5, 0x13B6, 0x13B7, 0x13B8, 0x13B9, 0x13BA, 0x13BB, + 0x13BC, 0x13BD, 0x13BE, 0x13BF, 0x13C0, 0x13C1, 0x13C2, 0x13C3, + 0x13C4, 0x13C5, 0x13C6, 0x13C7, 0x13C8, 0x13C9, 0x13CA, 0x13CB, + 0x13CC, 0x13CD, 0x13CE, 0x13CF, 0x13D0, 0x13D1, 0x13D2, 0x13D3, + 0x13D4, 0x13D5, 0x13D6, 0x13D7, 0x13D8, 0x13D9, 0x13DA, 0x13DB, + 0x13DC, 0x13DD, 0x13DE, 0x13DF, 0x13E0, 0x13E1, 0x13E2, 0x13E3, + 0x13E4, 0x13E5, 0x13E6, 0x13E7, 0x13E8, 0x13E9, 0x13EA, 0x13EB, + 0x13EC, 0x13ED, 0x13EE, 0x13EF, 0xFF41, 0xFF42, 0xFF43, 0xFF44, + 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, + 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, + 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A, 0x10428, 0x10429, + 0x1042A, 0x1042B, 0x1042C, 0x1042D, 0x1042E, 0x1042F, 0x10430, 0x10431, + 0x10432, 0x10433, 0x10434, 0x10435, 0x10436, 0x10437, 0x10438, 0x10439, + 0x1043A, 0x1043B, 0x1043C, 0x1043D, 0x1043E, 0x1043F, 0x10440, 0x10441, + 0x10442, 0x10443, 0x10444, 0x10445, 0x10446, 0x10447, 0x10448, 0x10449, + 0x1044A, 0x1044B, 0x1044C, 0x1044D, 0x1044E, 0x1044F, 0x104D8, 0x104D9, + 0x104DA, 0x104DB, 0x104DC, 0x104DD, 0x104DE, 0x104DF, 0x104E0, 0x104E1, + 0x104E2, 0x104E3, 0x104E4, 0x104E5, 0x104E6, 0x104E7, 0x104E8, 0x104E9, + 0x104EA, 0x104EB, 0x104EC, 0x104ED, 0x104EE, 0x104EF, 0x104F0, 0x104F1, + 0x104F2, 0x104F3, 0x104F4, 0x104F5, 0x104F6, 0x104F7, 0x104F8, 0x104F9, + 0x104FA, 0x104FB, 0x10597, 0x10598, 0x10599, 0x1059A, 0x1059B, 0x1059C, + 0x1059D, 0x1059E, 0x1059F, 0x105A0, 0x105A1, 0x105A3, 0x105A4, 0x105A5, + 0x105A6, 0x105A7, 0x105A8, 0x105A9, 0x105AA, 0x105AB, 0x105AC, 0x105AD, + 0x105AE, 0x105AF, 0x105B0, 0x105B1, 0x105B3, 0x105B4, 0x105B5, 0x105B6, + 0x105B7, 0x105B8, 0x105B9, 0x105BB, 0x105BC, 0x10CC0, 0x10CC1, 0x10CC2, + 0x10CC3, 0x10CC4, 0x10CC5, 0x10CC6, 0x10CC7, 0x10CC8, 0x10CC9, 0x10CCA, + 0x10CCB, 0x10CCC, 0x10CCD, 0x10CCE, 0x10CCF, 0x10CD0, 0x10CD1, 0x10CD2, + 0x10CD3, 0x10CD4, 0x10CD5, 0x10CD6, 0x10CD7, 0x10CD8, 0x10CD9, 0x10CDA, + 0x10CDB, 0x10CDC, 0x10CDD, 0x10CDE, 0x10CDF, 0x10CE0, 0x10CE1, 0x10CE2, + 0x10CE3, 0x10CE4, 0x10CE5, 0x10CE6, 0x10CE7, 0x10CE8, 0x10CE9, 0x10CEA, + 0x10CEB, 0x10CEC, 0x10CED, 0x10CEE, 0x10CEF, 0x10CF0, 0x10CF1, 0x10CF2, + 0x118C0, 0x118C1, 0x118C2, 0x118C3, 0x118C4, 0x118C5, 0x118C6, 0x118C7, + 0x118C8, 0x118C9, 0x118CA, 0x118CB, 0x118CC, 0x118CD, 0x118CE, 0x118CF, + 0x118D0, 0x118D1, 0x118D2, 0x118D3, 0x118D4, 0x118D5, 0x118D6, 0x118D7, + 0x118D8, 0x118D9, 0x118DA, 0x118DB, 0x118DC, 0x118DD, 0x118DE, 0x118DF, + 0x16E60, 0x16E61, 0x16E62, 0x16E63, 0x16E64, 0x16E65, 0x16E66, 0x16E67, + 0x16E68, 0x16E69, 0x16E6A, 0x16E6B, 0x16E6C, 0x16E6D, 0x16E6E, 0x16E6F, + 0x16E70, 0x16E71, 0x16E72, 0x16E73, 0x16E74, 0x16E75, 0x16E76, 0x16E77, + 0x16E78, 0x16E79, 0x16E7A, 0x16E7B, 0x16E7C, 0x16E7D, 0x16E7E, 0x16E7F, + 0x1E922, 0x1E923, 0x1E924, 0x1E925, 0x1E926, 0x1E927, 0x1E928, 0x1E929, + 0x1E92A, 0x1E92B, 0x1E92C, 0x1E92D, 0x1E92E, 0x1E92F, 0x1E930, 0x1E931, + 0x1E932, 0x1E933, 0x1E934, 0x1E935, 0x1E936, 0x1E937, 0x1E938, 0x1E939, + 0x1E93A, 0x1E93B, 0x1E93C, 0x1E93D, 0x1E93E, 0x1E93F, 0x1E940, 0x1E941, + 0x1E942, 0x1E943, +}; + +} diff --git a/include/boost/parser/parser.hpp b/include/boost/parser/parser.hpp index 3c709923..64c1b44b 100644 --- a/include/boost/parser/parser.hpp +++ b/include/boost/parser/parser.hpp @@ -8,6 +8,7 @@ #include #include #include +#include #include #include diff --git a/misc/generate_case_fold_data.py b/misc/generate_case_fold_data.py new file mode 100755 index 00000000..46375118 --- /dev/null +++ b/misc/generate_case_fold_data.py @@ -0,0 +1,122 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2024 T. Zachary Laine +# +# Distributed under the Boost Software License, Version 1.0. (See accompanying +# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +# Get the latest version of the data file at: +# https://www.unicode.org/Public/UCD/latest/ucd/CaseFolding.txt + +import itertools + +def print_structs(): + print('''struct short_mapping_range { + char32_t cp_first_; + char32_t cp_last_; + uint16_t stride_; + uint16_t first_idx_; +};''') + +f = open('CaseFolding.txt') + +lines = f.readlines() + +lines = filter( + lambda x: False if (x.startswith('#') or x == '\n' or ' T;' in x or ' S;' in x) else True, + lines) + +lines = list(map(lambda x: x.split(';')[:-1], lines)) + +f_line_indices = list(filter(lambda i: ' F;' in lines[i], range(len(lines)))) + +# Remove all C; lines that come before a F; line that applies to the same code +# point. +for f_idx in reversed(f_line_indices): + prev = f_idx - 1 + if 0 <= prev: + if lines[f_idx][0] == lines[prev][0]: + lines = lines[:prev] + lines[prev + 1:] + +# The mapping code points, in the order listed in lines (only individual mapping-cps). +all_mapping_cps = [] +max_mapping_len = 1 +# The mapping code points, in the order listed in lines (only multiple mapping-cps). +big_mappings = [] +for line in lines: + mappings = line[-1].strip().split(' ') + max_mapping_len = max(len(mappings), max_mapping_len) + if 1 < len(mappings): + big_mappings.append((line[0], mappings)) + else: + line.append(len(all_mapping_cps)) + all_mapping_cps += mappings + +def print_long_mapping(): + print(f'''inline constexpr int longest_mapping = {max_mapping_len}; +struct long_mapping {{ + char32_t cp_; + char32_t mapping_[longest_mapping + 1]; +}};''') + print(f'inline constexpr long_mapping long_mappings[{len(big_mappings)}] = {{') + for big_mapping in big_mappings: + mappings = ', '.join(map(lambda x: '0x' + x, big_mapping[1])) + print(f' {{0x{big_mapping[0]}, {{{mappings} , 0}}}},') + print('};') + +def print_mapping_cps(): + print(f'inline constexpr char32_t single_mapping_cps[{len(all_mapping_cps)}] = {{') + str_ = '' + idx = 0 + max_per_line = 8 + for cp in map(lambda x: '0x' + x, all_mapping_cps): + str_ += cp + ', ' + idx += 1 + if (idx % max_per_line) == 0: + print(' ' + str_) + str_ = '' + if idx % max_per_line: + print(' ' + str_) + print('};\n') + +# Each range consists of a first-index, last-index, and the stride of values +# within [first, last). +ranges = [] + +lines = list(filter(lambda x: len(x[2].strip().split(' ')) == 1, lines)) +pairs = zip(lines[:-1], lines[1:]) + +def pair_diff(pair): + prev_cp = int('0x' + pair[0][0], 0) + cp = int('0x' + pair[1][0], 0) + return cp - prev_cp + +for k, g in itertools.groupby(pairs, pair_diff): + g = list(g) + ranges.append((g[0][0][0], g[-1][1][0], k, g[0][0][-1])) +ranges[-1] = (ranges[-1][0], lines[-1][0] + ' + 1', ranges[-1][2], ranges[-1][3]) + +def print_ranges(): + print(f'inline constexpr short_mapping_range mapping_ranges[{len(ranges)}] = {{') + for r in ranges: + print(f' {{0x{r[0]}, 0x{r[1]}, {r[2]}, {r[3]}}}, ') + print('};') + +print('''// Copyright (c) 2024 T. Zachary Laine +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Warning: This header is auto-generated (see misc/generate_case_fold_data.py). +// The lack of include guards is intentional. + +namespace boost::parser::detail { + +''') + +print_structs() +print_long_mapping() +print_ranges() +print_mapping_cps() + +print('}') diff --git a/misc/generate_case_fold_tests.py b/misc/generate_case_fold_tests.py new file mode 100755 index 00000000..16cd9ea1 --- /dev/null +++ b/misc/generate_case_fold_tests.py @@ -0,0 +1,113 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2024 T. Zachary Laine +# +# Distributed under the Boost Software License, Version 1.0. (See accompanying +# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +# Get the latest version of the data file at: +# https://www.unicode.org/Public/UCD/latest/ucd/CaseFolding.txt + +import itertools + +f = open('CaseFolding.txt') + +lines = f.readlines() + +lines = filter( + lambda x: False if (x.startswith('#') or x == '\n' or ' T;' in x or ' S;' in x) else True, + lines) + +lines = list(map(lambda x: x.split(';')[:-1], lines)) + +f_line_indices = list(filter(lambda i: ' F;' in lines[i], range(len(lines)))) + +# Remove all C; lines that come before a F; line that applies to the same code +# point. +for f_idx in reversed(f_line_indices): + prev = f_idx - 1 + if 0 <= prev: + if lines[f_idx][0] == lines[prev][0]: + lines = lines[:prev] + lines[prev + 1:] + +max_mapping_len = 1 +for line in lines: + mappings = line[2].strip().split(' ') + max_mapping_len = max(len(mappings), max_mapping_len) + +def print_cps(): + print('// Initial code points from CaseFolding.txt') + print('char32_t const cps[] = {') + str_ = '' + idx = 0 + max_per_line = 8 + for cp in map(lambda x: '0x' + x[0], lines): + str_ += cp + ', ' + idx += 1 + if (idx % max_per_line) == 0: + print(' ' + str_) + str_ = '' + if idx % max_per_line: + print(' ' + str_) + print('};\n') + print(f'char32_t const max_test_cp = 0x{lines[-1][0]} + 100;\n') + + +array_t = f'std::array' + +def print_test(line): + num_mapping_cps = len(line[2].strip().split(' ')) + mapping = ', '.join(map(lambda x: '0x' + x, line[2].strip().split(' '))) + trailing = ', 0' * (max_mapping_len + 1 - num_mapping_cps) + zeros = ', 0' * (max_mapping_len) + print(f''' {{ + {array_t} const expected = {{ {mapping}{trailing} }}; + {array_t} result = {{ 0{zeros} }}; + boost::parser::detail::case_fold(0x{line[0]}, result.begin()); + EXPECT_EQ(result, expected) << 0x{line[0]} << " 0x{line[0]}"; + }}''') + +def print_tests(): + idx = 0 + max_per_TEST = 50 + print(f'TEST(case_folding, hits_{int(idx / max_per_TEST)}) {{') + for line in lines: + idx += 1 + if (idx % max_per_TEST) == 0: + print(f'''}} + +TEST(case_folding, test_{int(idx / max_per_TEST)}) {{''') + print_test(line) + print('}\n') + +print('''// Copyright (c) 2024 T. Zachary Laine +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Warning: This header is auto-generated (see misc/generate_case_fold_tests.py). + +#include + +#include + + +''') + +print_cps() +print_tests() + +print(f'''TEST(case_folding, misses) {{ + char32_t next_cp = 0; + for (char32_t const * it = cps; it != std::end(cps); ++it) {{ + for (char32_t cp = next_cp; cp < *it; ++cp) {{ + {array_t} const expected = {{ cp, 0 }}; + {array_t} result = {{ 0 }}; + auto const first = result.data(); + auto const last = boost::parser::detail::case_fold(cp, first); + EXPECT_TRUE(std::equal(first, last, expected.begin())); + EXPECT_EQ(result, expected) << cp; + }} + next_cp = *it + 1; + }} +}}''') diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index c6be534d..4c5d8f31 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -67,3 +67,4 @@ add_test_executable(parser_symbol_table) add_test_executable(tracing) add_test_executable(parse_empty) add_test_executable(tuple_aggregate) +add_test_executable(case_fold_generated) diff --git a/test/case_fold_generated.cpp b/test/case_fold_generated.cpp new file mode 100644 index 00000000..047bea3c --- /dev/null +++ b/test/case_fold_generated.cpp @@ -0,0 +1,9498 @@ +// Copyright (c) 2024 T. Zachary Laine +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Warning: This header is auto-generated (see misc/generate_case_fold_tests.py). + +#include + +#include + + + +// Initial code points from CaseFolding.txt +char32_t const cps[] = { + 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, + 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, + 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, + 0x0059, 0x005A, 0x00B5, 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, + 0x00C5, 0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, + 0x00CD, 0x00CE, 0x00CF, 0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, + 0x00D5, 0x00D6, 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, + 0x00DE, 0x00DF, 0x0100, 0x0102, 0x0104, 0x0106, 0x0108, 0x010A, + 0x010C, 0x010E, 0x0110, 0x0112, 0x0114, 0x0116, 0x0118, 0x011A, + 0x011C, 0x011E, 0x0120, 0x0122, 0x0124, 0x0126, 0x0128, 0x012A, + 0x012C, 0x012E, 0x0130, 0x0132, 0x0134, 0x0136, 0x0139, 0x013B, + 0x013D, 0x013F, 0x0141, 0x0143, 0x0145, 0x0147, 0x0149, 0x014A, + 0x014C, 0x014E, 0x0150, 0x0152, 0x0154, 0x0156, 0x0158, 0x015A, + 0x015C, 0x015E, 0x0160, 0x0162, 0x0164, 0x0166, 0x0168, 0x016A, + 0x016C, 0x016E, 0x0170, 0x0172, 0x0174, 0x0176, 0x0178, 0x0179, + 0x017B, 0x017D, 0x017F, 0x0181, 0x0182, 0x0184, 0x0186, 0x0187, + 0x0189, 0x018A, 0x018B, 0x018E, 0x018F, 0x0190, 0x0191, 0x0193, + 0x0194, 0x0196, 0x0197, 0x0198, 0x019C, 0x019D, 0x019F, 0x01A0, + 0x01A2, 0x01A4, 0x01A6, 0x01A7, 0x01A9, 0x01AC, 0x01AE, 0x01AF, + 0x01B1, 0x01B2, 0x01B3, 0x01B5, 0x01B7, 0x01B8, 0x01BC, 0x01C4, + 0x01C5, 0x01C7, 0x01C8, 0x01CA, 0x01CB, 0x01CD, 0x01CF, 0x01D1, + 0x01D3, 0x01D5, 0x01D7, 0x01D9, 0x01DB, 0x01DE, 0x01E0, 0x01E2, + 0x01E4, 0x01E6, 0x01E8, 0x01EA, 0x01EC, 0x01EE, 0x01F0, 0x01F1, + 0x01F2, 0x01F4, 0x01F6, 0x01F7, 0x01F8, 0x01FA, 0x01FC, 0x01FE, + 0x0200, 0x0202, 0x0204, 0x0206, 0x0208, 0x020A, 0x020C, 0x020E, + 0x0210, 0x0212, 0x0214, 0x0216, 0x0218, 0x021A, 0x021C, 0x021E, + 0x0220, 0x0222, 0x0224, 0x0226, 0x0228, 0x022A, 0x022C, 0x022E, + 0x0230, 0x0232, 0x023A, 0x023B, 0x023D, 0x023E, 0x0241, 0x0243, + 0x0244, 0x0245, 0x0246, 0x0248, 0x024A, 0x024C, 0x024E, 0x0345, + 0x0370, 0x0372, 0x0376, 0x037F, 0x0386, 0x0388, 0x0389, 0x038A, + 0x038C, 0x038E, 0x038F, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, + 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x039B, 0x039C, + 0x039D, 0x039E, 0x039F, 0x03A0, 0x03A1, 0x03A3, 0x03A4, 0x03A5, + 0x03A6, 0x03A7, 0x03A8, 0x03A9, 0x03AA, 0x03AB, 0x03B0, 0x03C2, + 0x03CF, 0x03D0, 0x03D1, 0x03D5, 0x03D6, 0x03D8, 0x03DA, 0x03DC, + 0x03DE, 0x03E0, 0x03E2, 0x03E4, 0x03E6, 0x03E8, 0x03EA, 0x03EC, + 0x03EE, 0x03F0, 0x03F1, 0x03F4, 0x03F5, 0x03F7, 0x03F9, 0x03FA, + 0x03FD, 0x03FE, 0x03FF, 0x0400, 0x0401, 0x0402, 0x0403, 0x0404, + 0x0405, 0x0406, 0x0407, 0x0408, 0x0409, 0x040A, 0x040B, 0x040C, + 0x040D, 0x040E, 0x040F, 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, + 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, + 0x041D, 0x041E, 0x041F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0424, + 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, + 0x042D, 0x042E, 0x042F, 0x0460, 0x0462, 0x0464, 0x0466, 0x0468, + 0x046A, 0x046C, 0x046E, 0x0470, 0x0472, 0x0474, 0x0476, 0x0478, + 0x047A, 0x047C, 0x047E, 0x0480, 0x048A, 0x048C, 0x048E, 0x0490, + 0x0492, 0x0494, 0x0496, 0x0498, 0x049A, 0x049C, 0x049E, 0x04A0, + 0x04A2, 0x04A4, 0x04A6, 0x04A8, 0x04AA, 0x04AC, 0x04AE, 0x04B0, + 0x04B2, 0x04B4, 0x04B6, 0x04B8, 0x04BA, 0x04BC, 0x04BE, 0x04C0, + 0x04C1, 0x04C3, 0x04C5, 0x04C7, 0x04C9, 0x04CB, 0x04CD, 0x04D0, + 0x04D2, 0x04D4, 0x04D6, 0x04D8, 0x04DA, 0x04DC, 0x04DE, 0x04E0, + 0x04E2, 0x04E4, 0x04E6, 0x04E8, 0x04EA, 0x04EC, 0x04EE, 0x04F0, + 0x04F2, 0x04F4, 0x04F6, 0x04F8, 0x04FA, 0x04FC, 0x04FE, 0x0500, + 0x0502, 0x0504, 0x0506, 0x0508, 0x050A, 0x050C, 0x050E, 0x0510, + 0x0512, 0x0514, 0x0516, 0x0518, 0x051A, 0x051C, 0x051E, 0x0520, + 0x0522, 0x0524, 0x0526, 0x0528, 0x052A, 0x052C, 0x052E, 0x0531, + 0x0532, 0x0533, 0x0534, 0x0535, 0x0536, 0x0537, 0x0538, 0x0539, + 0x053A, 0x053B, 0x053C, 0x053D, 0x053E, 0x053F, 0x0540, 0x0541, + 0x0542, 0x0543, 0x0544, 0x0545, 0x0546, 0x0547, 0x0548, 0x0549, + 0x054A, 0x054B, 0x054C, 0x054D, 0x054E, 0x054F, 0x0550, 0x0551, + 0x0552, 0x0553, 0x0554, 0x0555, 0x0556, 0x0587, 0x10A0, 0x10A1, + 0x10A2, 0x10A3, 0x10A4, 0x10A5, 0x10A6, 0x10A7, 0x10A8, 0x10A9, + 0x10AA, 0x10AB, 0x10AC, 0x10AD, 0x10AE, 0x10AF, 0x10B0, 0x10B1, + 0x10B2, 0x10B3, 0x10B4, 0x10B5, 0x10B6, 0x10B7, 0x10B8, 0x10B9, + 0x10BA, 0x10BB, 0x10BC, 0x10BD, 0x10BE, 0x10BF, 0x10C0, 0x10C1, + 0x10C2, 0x10C3, 0x10C4, 0x10C5, 0x10C7, 0x10CD, 0x13F8, 0x13F9, + 0x13FA, 0x13FB, 0x13FC, 0x13FD, 0x1C80, 0x1C81, 0x1C82, 0x1C83, + 0x1C84, 0x1C85, 0x1C86, 0x1C87, 0x1C88, 0x1C90, 0x1C91, 0x1C92, + 0x1C93, 0x1C94, 0x1C95, 0x1C96, 0x1C97, 0x1C98, 0x1C99, 0x1C9A, + 0x1C9B, 0x1C9C, 0x1C9D, 0x1C9E, 0x1C9F, 0x1CA0, 0x1CA1, 0x1CA2, + 0x1CA3, 0x1CA4, 0x1CA5, 0x1CA6, 0x1CA7, 0x1CA8, 0x1CA9, 0x1CAA, + 0x1CAB, 0x1CAC, 0x1CAD, 0x1CAE, 0x1CAF, 0x1CB0, 0x1CB1, 0x1CB2, + 0x1CB3, 0x1CB4, 0x1CB5, 0x1CB6, 0x1CB7, 0x1CB8, 0x1CB9, 0x1CBA, + 0x1CBD, 0x1CBE, 0x1CBF, 0x1E00, 0x1E02, 0x1E04, 0x1E06, 0x1E08, + 0x1E0A, 0x1E0C, 0x1E0E, 0x1E10, 0x1E12, 0x1E14, 0x1E16, 0x1E18, + 0x1E1A, 0x1E1C, 0x1E1E, 0x1E20, 0x1E22, 0x1E24, 0x1E26, 0x1E28, + 0x1E2A, 0x1E2C, 0x1E2E, 0x1E30, 0x1E32, 0x1E34, 0x1E36, 0x1E38, + 0x1E3A, 0x1E3C, 0x1E3E, 0x1E40, 0x1E42, 0x1E44, 0x1E46, 0x1E48, + 0x1E4A, 0x1E4C, 0x1E4E, 0x1E50, 0x1E52, 0x1E54, 0x1E56, 0x1E58, + 0x1E5A, 0x1E5C, 0x1E5E, 0x1E60, 0x1E62, 0x1E64, 0x1E66, 0x1E68, + 0x1E6A, 0x1E6C, 0x1E6E, 0x1E70, 0x1E72, 0x1E74, 0x1E76, 0x1E78, + 0x1E7A, 0x1E7C, 0x1E7E, 0x1E80, 0x1E82, 0x1E84, 0x1E86, 0x1E88, + 0x1E8A, 0x1E8C, 0x1E8E, 0x1E90, 0x1E92, 0x1E94, 0x1E96, 0x1E97, + 0x1E98, 0x1E99, 0x1E9A, 0x1E9B, 0x1E9E, 0x1EA0, 0x1EA2, 0x1EA4, + 0x1EA6, 0x1EA8, 0x1EAA, 0x1EAC, 0x1EAE, 0x1EB0, 0x1EB2, 0x1EB4, + 0x1EB6, 0x1EB8, 0x1EBA, 0x1EBC, 0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, + 0x1EC6, 0x1EC8, 0x1ECA, 0x1ECC, 0x1ECE, 0x1ED0, 0x1ED2, 0x1ED4, + 0x1ED6, 0x1ED8, 0x1EDA, 0x1EDC, 0x1EDE, 0x1EE0, 0x1EE2, 0x1EE4, + 0x1EE6, 0x1EE8, 0x1EEA, 0x1EEC, 0x1EEE, 0x1EF0, 0x1EF2, 0x1EF4, + 0x1EF6, 0x1EF8, 0x1EFA, 0x1EFC, 0x1EFE, 0x1F08, 0x1F09, 0x1F0A, + 0x1F0B, 0x1F0C, 0x1F0D, 0x1F0E, 0x1F0F, 0x1F18, 0x1F19, 0x1F1A, + 0x1F1B, 0x1F1C, 0x1F1D, 0x1F28, 0x1F29, 0x1F2A, 0x1F2B, 0x1F2C, + 0x1F2D, 0x1F2E, 0x1F2F, 0x1F38, 0x1F39, 0x1F3A, 0x1F3B, 0x1F3C, + 0x1F3D, 0x1F3E, 0x1F3F, 0x1F48, 0x1F49, 0x1F4A, 0x1F4B, 0x1F4C, + 0x1F4D, 0x1F50, 0x1F52, 0x1F54, 0x1F56, 0x1F59, 0x1F5B, 0x1F5D, + 0x1F5F, 0x1F68, 0x1F69, 0x1F6A, 0x1F6B, 0x1F6C, 0x1F6D, 0x1F6E, + 0x1F6F, 0x1F80, 0x1F81, 0x1F82, 0x1F83, 0x1F84, 0x1F85, 0x1F86, + 0x1F87, 0x1F88, 0x1F89, 0x1F8A, 0x1F8B, 0x1F8C, 0x1F8D, 0x1F8E, + 0x1F8F, 0x1F90, 0x1F91, 0x1F92, 0x1F93, 0x1F94, 0x1F95, 0x1F96, + 0x1F97, 0x1F98, 0x1F99, 0x1F9A, 0x1F9B, 0x1F9C, 0x1F9D, 0x1F9E, + 0x1F9F, 0x1FA0, 0x1FA1, 0x1FA2, 0x1FA3, 0x1FA4, 0x1FA5, 0x1FA6, + 0x1FA7, 0x1FA8, 0x1FA9, 0x1FAA, 0x1FAB, 0x1FAC, 0x1FAD, 0x1FAE, + 0x1FAF, 0x1FB2, 0x1FB3, 0x1FB4, 0x1FB6, 0x1FB7, 0x1FB8, 0x1FB9, + 0x1FBA, 0x1FBB, 0x1FBC, 0x1FBE, 0x1FC2, 0x1FC3, 0x1FC4, 0x1FC6, + 0x1FC7, 0x1FC8, 0x1FC9, 0x1FCA, 0x1FCB, 0x1FCC, 0x1FD2, 0x1FD3, + 0x1FD6, 0x1FD7, 0x1FD8, 0x1FD9, 0x1FDA, 0x1FDB, 0x1FE2, 0x1FE3, + 0x1FE4, 0x1FE6, 0x1FE7, 0x1FE8, 0x1FE9, 0x1FEA, 0x1FEB, 0x1FEC, + 0x1FF2, 0x1FF3, 0x1FF4, 0x1FF6, 0x1FF7, 0x1FF8, 0x1FF9, 0x1FFA, + 0x1FFB, 0x1FFC, 0x2126, 0x212A, 0x212B, 0x2132, 0x2160, 0x2161, + 0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, + 0x216A, 0x216B, 0x216C, 0x216D, 0x216E, 0x216F, 0x2183, 0x24B6, + 0x24B7, 0x24B8, 0x24B9, 0x24BA, 0x24BB, 0x24BC, 0x24BD, 0x24BE, + 0x24BF, 0x24C0, 0x24C1, 0x24C2, 0x24C3, 0x24C4, 0x24C5, 0x24C6, + 0x24C7, 0x24C8, 0x24C9, 0x24CA, 0x24CB, 0x24CC, 0x24CD, 0x24CE, + 0x24CF, 0x2C00, 0x2C01, 0x2C02, 0x2C03, 0x2C04, 0x2C05, 0x2C06, + 0x2C07, 0x2C08, 0x2C09, 0x2C0A, 0x2C0B, 0x2C0C, 0x2C0D, 0x2C0E, + 0x2C0F, 0x2C10, 0x2C11, 0x2C12, 0x2C13, 0x2C14, 0x2C15, 0x2C16, + 0x2C17, 0x2C18, 0x2C19, 0x2C1A, 0x2C1B, 0x2C1C, 0x2C1D, 0x2C1E, + 0x2C1F, 0x2C20, 0x2C21, 0x2C22, 0x2C23, 0x2C24, 0x2C25, 0x2C26, + 0x2C27, 0x2C28, 0x2C29, 0x2C2A, 0x2C2B, 0x2C2C, 0x2C2D, 0x2C2E, + 0x2C2F, 0x2C60, 0x2C62, 0x2C63, 0x2C64, 0x2C67, 0x2C69, 0x2C6B, + 0x2C6D, 0x2C6E, 0x2C6F, 0x2C70, 0x2C72, 0x2C75, 0x2C7E, 0x2C7F, + 0x2C80, 0x2C82, 0x2C84, 0x2C86, 0x2C88, 0x2C8A, 0x2C8C, 0x2C8E, + 0x2C90, 0x2C92, 0x2C94, 0x2C96, 0x2C98, 0x2C9A, 0x2C9C, 0x2C9E, + 0x2CA0, 0x2CA2, 0x2CA4, 0x2CA6, 0x2CA8, 0x2CAA, 0x2CAC, 0x2CAE, + 0x2CB0, 0x2CB2, 0x2CB4, 0x2CB6, 0x2CB8, 0x2CBA, 0x2CBC, 0x2CBE, + 0x2CC0, 0x2CC2, 0x2CC4, 0x2CC6, 0x2CC8, 0x2CCA, 0x2CCC, 0x2CCE, + 0x2CD0, 0x2CD2, 0x2CD4, 0x2CD6, 0x2CD8, 0x2CDA, 0x2CDC, 0x2CDE, + 0x2CE0, 0x2CE2, 0x2CEB, 0x2CED, 0x2CF2, 0xA640, 0xA642, 0xA644, + 0xA646, 0xA648, 0xA64A, 0xA64C, 0xA64E, 0xA650, 0xA652, 0xA654, + 0xA656, 0xA658, 0xA65A, 0xA65C, 0xA65E, 0xA660, 0xA662, 0xA664, + 0xA666, 0xA668, 0xA66A, 0xA66C, 0xA680, 0xA682, 0xA684, 0xA686, + 0xA688, 0xA68A, 0xA68C, 0xA68E, 0xA690, 0xA692, 0xA694, 0xA696, + 0xA698, 0xA69A, 0xA722, 0xA724, 0xA726, 0xA728, 0xA72A, 0xA72C, + 0xA72E, 0xA732, 0xA734, 0xA736, 0xA738, 0xA73A, 0xA73C, 0xA73E, + 0xA740, 0xA742, 0xA744, 0xA746, 0xA748, 0xA74A, 0xA74C, 0xA74E, + 0xA750, 0xA752, 0xA754, 0xA756, 0xA758, 0xA75A, 0xA75C, 0xA75E, + 0xA760, 0xA762, 0xA764, 0xA766, 0xA768, 0xA76A, 0xA76C, 0xA76E, + 0xA779, 0xA77B, 0xA77D, 0xA77E, 0xA780, 0xA782, 0xA784, 0xA786, + 0xA78B, 0xA78D, 0xA790, 0xA792, 0xA796, 0xA798, 0xA79A, 0xA79C, + 0xA79E, 0xA7A0, 0xA7A2, 0xA7A4, 0xA7A6, 0xA7A8, 0xA7AA, 0xA7AB, + 0xA7AC, 0xA7AD, 0xA7AE, 0xA7B0, 0xA7B1, 0xA7B2, 0xA7B3, 0xA7B4, + 0xA7B6, 0xA7B8, 0xA7BA, 0xA7BC, 0xA7BE, 0xA7C0, 0xA7C2, 0xA7C4, + 0xA7C5, 0xA7C6, 0xA7C7, 0xA7C9, 0xA7D0, 0xA7D6, 0xA7D8, 0xA7F5, + 0xAB70, 0xAB71, 0xAB72, 0xAB73, 0xAB74, 0xAB75, 0xAB76, 0xAB77, + 0xAB78, 0xAB79, 0xAB7A, 0xAB7B, 0xAB7C, 0xAB7D, 0xAB7E, 0xAB7F, + 0xAB80, 0xAB81, 0xAB82, 0xAB83, 0xAB84, 0xAB85, 0xAB86, 0xAB87, + 0xAB88, 0xAB89, 0xAB8A, 0xAB8B, 0xAB8C, 0xAB8D, 0xAB8E, 0xAB8F, + 0xAB90, 0xAB91, 0xAB92, 0xAB93, 0xAB94, 0xAB95, 0xAB96, 0xAB97, + 0xAB98, 0xAB99, 0xAB9A, 0xAB9B, 0xAB9C, 0xAB9D, 0xAB9E, 0xAB9F, + 0xABA0, 0xABA1, 0xABA2, 0xABA3, 0xABA4, 0xABA5, 0xABA6, 0xABA7, + 0xABA8, 0xABA9, 0xABAA, 0xABAB, 0xABAC, 0xABAD, 0xABAE, 0xABAF, + 0xABB0, 0xABB1, 0xABB2, 0xABB3, 0xABB4, 0xABB5, 0xABB6, 0xABB7, + 0xABB8, 0xABB9, 0xABBA, 0xABBB, 0xABBC, 0xABBD, 0xABBE, 0xABBF, + 0xFB00, 0xFB01, 0xFB02, 0xFB03, 0xFB04, 0xFB05, 0xFB06, 0xFB13, + 0xFB14, 0xFB15, 0xFB16, 0xFB17, 0xFF21, 0xFF22, 0xFF23, 0xFF24, + 0xFF25, 0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, + 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, + 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A, 0x10400, 0x10401, + 0x10402, 0x10403, 0x10404, 0x10405, 0x10406, 0x10407, 0x10408, 0x10409, + 0x1040A, 0x1040B, 0x1040C, 0x1040D, 0x1040E, 0x1040F, 0x10410, 0x10411, + 0x10412, 0x10413, 0x10414, 0x10415, 0x10416, 0x10417, 0x10418, 0x10419, + 0x1041A, 0x1041B, 0x1041C, 0x1041D, 0x1041E, 0x1041F, 0x10420, 0x10421, + 0x10422, 0x10423, 0x10424, 0x10425, 0x10426, 0x10427, 0x104B0, 0x104B1, + 0x104B2, 0x104B3, 0x104B4, 0x104B5, 0x104B6, 0x104B7, 0x104B8, 0x104B9, + 0x104BA, 0x104BB, 0x104BC, 0x104BD, 0x104BE, 0x104BF, 0x104C0, 0x104C1, + 0x104C2, 0x104C3, 0x104C4, 0x104C5, 0x104C6, 0x104C7, 0x104C8, 0x104C9, + 0x104CA, 0x104CB, 0x104CC, 0x104CD, 0x104CE, 0x104CF, 0x104D0, 0x104D1, + 0x104D2, 0x104D3, 0x10570, 0x10571, 0x10572, 0x10573, 0x10574, 0x10575, + 0x10576, 0x10577, 0x10578, 0x10579, 0x1057A, 0x1057C, 0x1057D, 0x1057E, + 0x1057F, 0x10580, 0x10581, 0x10582, 0x10583, 0x10584, 0x10585, 0x10586, + 0x10587, 0x10588, 0x10589, 0x1058A, 0x1058C, 0x1058D, 0x1058E, 0x1058F, + 0x10590, 0x10591, 0x10592, 0x10594, 0x10595, 0x10C80, 0x10C81, 0x10C82, + 0x10C83, 0x10C84, 0x10C85, 0x10C86, 0x10C87, 0x10C88, 0x10C89, 0x10C8A, + 0x10C8B, 0x10C8C, 0x10C8D, 0x10C8E, 0x10C8F, 0x10C90, 0x10C91, 0x10C92, + 0x10C93, 0x10C94, 0x10C95, 0x10C96, 0x10C97, 0x10C98, 0x10C99, 0x10C9A, + 0x10C9B, 0x10C9C, 0x10C9D, 0x10C9E, 0x10C9F, 0x10CA0, 0x10CA1, 0x10CA2, + 0x10CA3, 0x10CA4, 0x10CA5, 0x10CA6, 0x10CA7, 0x10CA8, 0x10CA9, 0x10CAA, + 0x10CAB, 0x10CAC, 0x10CAD, 0x10CAE, 0x10CAF, 0x10CB0, 0x10CB1, 0x10CB2, + 0x118A0, 0x118A1, 0x118A2, 0x118A3, 0x118A4, 0x118A5, 0x118A6, 0x118A7, + 0x118A8, 0x118A9, 0x118AA, 0x118AB, 0x118AC, 0x118AD, 0x118AE, 0x118AF, + 0x118B0, 0x118B1, 0x118B2, 0x118B3, 0x118B4, 0x118B5, 0x118B6, 0x118B7, + 0x118B8, 0x118B9, 0x118BA, 0x118BB, 0x118BC, 0x118BD, 0x118BE, 0x118BF, + 0x16E40, 0x16E41, 0x16E42, 0x16E43, 0x16E44, 0x16E45, 0x16E46, 0x16E47, + 0x16E48, 0x16E49, 0x16E4A, 0x16E4B, 0x16E4C, 0x16E4D, 0x16E4E, 0x16E4F, + 0x16E50, 0x16E51, 0x16E52, 0x16E53, 0x16E54, 0x16E55, 0x16E56, 0x16E57, + 0x16E58, 0x16E59, 0x16E5A, 0x16E5B, 0x16E5C, 0x16E5D, 0x16E5E, 0x16E5F, + 0x1E900, 0x1E901, 0x1E902, 0x1E903, 0x1E904, 0x1E905, 0x1E906, 0x1E907, + 0x1E908, 0x1E909, 0x1E90A, 0x1E90B, 0x1E90C, 0x1E90D, 0x1E90E, 0x1E90F, + 0x1E910, 0x1E911, 0x1E912, 0x1E913, 0x1E914, 0x1E915, 0x1E916, 0x1E917, + 0x1E918, 0x1E919, 0x1E91A, 0x1E91B, 0x1E91C, 0x1E91D, 0x1E91E, 0x1E91F, + 0x1E920, 0x1E921, +}; + +char32_t const max_test_cp = 0x1E921 + 100; + +TEST(case_folding, hits_0) { + { + std::array const expected = { 0x0061, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0041, result.begin()); + EXPECT_EQ(result, expected) << 0x0041 << " 0x0041"; + } + { + std::array const expected = { 0x0062, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0042, result.begin()); + EXPECT_EQ(result, expected) << 0x0042 << " 0x0042"; + } + { + std::array const expected = { 0x0063, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0043, result.begin()); + EXPECT_EQ(result, expected) << 0x0043 << " 0x0043"; + } + { + std::array const expected = { 0x0064, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0044, result.begin()); + EXPECT_EQ(result, expected) << 0x0044 << " 0x0044"; + } + { + std::array const expected = { 0x0065, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0045, result.begin()); + EXPECT_EQ(result, expected) << 0x0045 << " 0x0045"; + } + { + std::array const expected = { 0x0066, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0046, result.begin()); + EXPECT_EQ(result, expected) << 0x0046 << " 0x0046"; + } + { + std::array const expected = { 0x0067, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0047, result.begin()); + EXPECT_EQ(result, expected) << 0x0047 << " 0x0047"; + } + { + std::array const expected = { 0x0068, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0048, result.begin()); + EXPECT_EQ(result, expected) << 0x0048 << " 0x0048"; + } + { + std::array const expected = { 0x0069, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0049, result.begin()); + EXPECT_EQ(result, expected) << 0x0049 << " 0x0049"; + } + { + std::array const expected = { 0x006A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x004A, result.begin()); + EXPECT_EQ(result, expected) << 0x004A << " 0x004A"; + } + { + std::array const expected = { 0x006B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x004B, result.begin()); + EXPECT_EQ(result, expected) << 0x004B << " 0x004B"; + } + { + std::array const expected = { 0x006C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x004C, result.begin()); + EXPECT_EQ(result, expected) << 0x004C << " 0x004C"; + } + { + std::array const expected = { 0x006D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x004D, result.begin()); + EXPECT_EQ(result, expected) << 0x004D << " 0x004D"; + } + { + std::array const expected = { 0x006E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x004E, result.begin()); + EXPECT_EQ(result, expected) << 0x004E << " 0x004E"; + } + { + std::array const expected = { 0x006F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x004F, result.begin()); + EXPECT_EQ(result, expected) << 0x004F << " 0x004F"; + } + { + std::array const expected = { 0x0070, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0050, result.begin()); + EXPECT_EQ(result, expected) << 0x0050 << " 0x0050"; + } + { + std::array const expected = { 0x0071, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0051, result.begin()); + EXPECT_EQ(result, expected) << 0x0051 << " 0x0051"; + } + { + std::array const expected = { 0x0072, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0052, result.begin()); + EXPECT_EQ(result, expected) << 0x0052 << " 0x0052"; + } + { + std::array const expected = { 0x0073, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0053, result.begin()); + EXPECT_EQ(result, expected) << 0x0053 << " 0x0053"; + } + { + std::array const expected = { 0x0074, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0054, result.begin()); + EXPECT_EQ(result, expected) << 0x0054 << " 0x0054"; + } + { + std::array const expected = { 0x0075, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0055, result.begin()); + EXPECT_EQ(result, expected) << 0x0055 << " 0x0055"; + } + { + std::array const expected = { 0x0076, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0056, result.begin()); + EXPECT_EQ(result, expected) << 0x0056 << " 0x0056"; + } + { + std::array const expected = { 0x0077, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0057, result.begin()); + EXPECT_EQ(result, expected) << 0x0057 << " 0x0057"; + } + { + std::array const expected = { 0x0078, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0058, result.begin()); + EXPECT_EQ(result, expected) << 0x0058 << " 0x0058"; + } + { + std::array const expected = { 0x0079, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0059, result.begin()); + EXPECT_EQ(result, expected) << 0x0059 << " 0x0059"; + } + { + std::array const expected = { 0x007A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x005A, result.begin()); + EXPECT_EQ(result, expected) << 0x005A << " 0x005A"; + } + { + std::array const expected = { 0x03BC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00B5, result.begin()); + EXPECT_EQ(result, expected) << 0x00B5 << " 0x00B5"; + } + { + std::array const expected = { 0x00E0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00C0, result.begin()); + EXPECT_EQ(result, expected) << 0x00C0 << " 0x00C0"; + } + { + std::array const expected = { 0x00E1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00C1, result.begin()); + EXPECT_EQ(result, expected) << 0x00C1 << " 0x00C1"; + } + { + std::array const expected = { 0x00E2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00C2, result.begin()); + EXPECT_EQ(result, expected) << 0x00C2 << " 0x00C2"; + } + { + std::array const expected = { 0x00E3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00C3, result.begin()); + EXPECT_EQ(result, expected) << 0x00C3 << " 0x00C3"; + } + { + std::array const expected = { 0x00E4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00C4, result.begin()); + EXPECT_EQ(result, expected) << 0x00C4 << " 0x00C4"; + } + { + std::array const expected = { 0x00E5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00C5, result.begin()); + EXPECT_EQ(result, expected) << 0x00C5 << " 0x00C5"; + } + { + std::array const expected = { 0x00E6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00C6, result.begin()); + EXPECT_EQ(result, expected) << 0x00C6 << " 0x00C6"; + } + { + std::array const expected = { 0x00E7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00C7, result.begin()); + EXPECT_EQ(result, expected) << 0x00C7 << " 0x00C7"; + } + { + std::array const expected = { 0x00E8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00C8, result.begin()); + EXPECT_EQ(result, expected) << 0x00C8 << " 0x00C8"; + } + { + std::array const expected = { 0x00E9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00C9, result.begin()); + EXPECT_EQ(result, expected) << 0x00C9 << " 0x00C9"; + } + { + std::array const expected = { 0x00EA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00CA, result.begin()); + EXPECT_EQ(result, expected) << 0x00CA << " 0x00CA"; + } + { + std::array const expected = { 0x00EB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00CB, result.begin()); + EXPECT_EQ(result, expected) << 0x00CB << " 0x00CB"; + } + { + std::array const expected = { 0x00EC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00CC, result.begin()); + EXPECT_EQ(result, expected) << 0x00CC << " 0x00CC"; + } + { + std::array const expected = { 0x00ED, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00CD, result.begin()); + EXPECT_EQ(result, expected) << 0x00CD << " 0x00CD"; + } + { + std::array const expected = { 0x00EE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00CE, result.begin()); + EXPECT_EQ(result, expected) << 0x00CE << " 0x00CE"; + } + { + std::array const expected = { 0x00EF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00CF, result.begin()); + EXPECT_EQ(result, expected) << 0x00CF << " 0x00CF"; + } + { + std::array const expected = { 0x00F0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00D0, result.begin()); + EXPECT_EQ(result, expected) << 0x00D0 << " 0x00D0"; + } + { + std::array const expected = { 0x00F1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00D1, result.begin()); + EXPECT_EQ(result, expected) << 0x00D1 << " 0x00D1"; + } + { + std::array const expected = { 0x00F2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00D2, result.begin()); + EXPECT_EQ(result, expected) << 0x00D2 << " 0x00D2"; + } + { + std::array const expected = { 0x00F3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00D3, result.begin()); + EXPECT_EQ(result, expected) << 0x00D3 << " 0x00D3"; + } + { + std::array const expected = { 0x00F4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00D4, result.begin()); + EXPECT_EQ(result, expected) << 0x00D4 << " 0x00D4"; + } + { + std::array const expected = { 0x00F5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00D5, result.begin()); + EXPECT_EQ(result, expected) << 0x00D5 << " 0x00D5"; + } +} + +TEST(case_folding, test_1) { + { + std::array const expected = { 0x00F6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00D6, result.begin()); + EXPECT_EQ(result, expected) << 0x00D6 << " 0x00D6"; + } + { + std::array const expected = { 0x00F8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00D8, result.begin()); + EXPECT_EQ(result, expected) << 0x00D8 << " 0x00D8"; + } + { + std::array const expected = { 0x00F9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00D9, result.begin()); + EXPECT_EQ(result, expected) << 0x00D9 << " 0x00D9"; + } + { + std::array const expected = { 0x00FA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00DA, result.begin()); + EXPECT_EQ(result, expected) << 0x00DA << " 0x00DA"; + } + { + std::array const expected = { 0x00FB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00DB, result.begin()); + EXPECT_EQ(result, expected) << 0x00DB << " 0x00DB"; + } + { + std::array const expected = { 0x00FC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00DC, result.begin()); + EXPECT_EQ(result, expected) << 0x00DC << " 0x00DC"; + } + { + std::array const expected = { 0x00FD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00DD, result.begin()); + EXPECT_EQ(result, expected) << 0x00DD << " 0x00DD"; + } + { + std::array const expected = { 0x00FE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00DE, result.begin()); + EXPECT_EQ(result, expected) << 0x00DE << " 0x00DE"; + } + { + std::array const expected = { 0x0073, 0x0073, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x00DF, result.begin()); + EXPECT_EQ(result, expected) << 0x00DF << " 0x00DF"; + } + { + std::array const expected = { 0x0101, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0100, result.begin()); + EXPECT_EQ(result, expected) << 0x0100 << " 0x0100"; + } + { + std::array const expected = { 0x0103, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0102, result.begin()); + EXPECT_EQ(result, expected) << 0x0102 << " 0x0102"; + } + { + std::array const expected = { 0x0105, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0104, result.begin()); + EXPECT_EQ(result, expected) << 0x0104 << " 0x0104"; + } + { + std::array const expected = { 0x0107, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0106, result.begin()); + EXPECT_EQ(result, expected) << 0x0106 << " 0x0106"; + } + { + std::array const expected = { 0x0109, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0108, result.begin()); + EXPECT_EQ(result, expected) << 0x0108 << " 0x0108"; + } + { + std::array const expected = { 0x010B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x010A, result.begin()); + EXPECT_EQ(result, expected) << 0x010A << " 0x010A"; + } + { + std::array const expected = { 0x010D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x010C, result.begin()); + EXPECT_EQ(result, expected) << 0x010C << " 0x010C"; + } + { + std::array const expected = { 0x010F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x010E, result.begin()); + EXPECT_EQ(result, expected) << 0x010E << " 0x010E"; + } + { + std::array const expected = { 0x0111, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0110, result.begin()); + EXPECT_EQ(result, expected) << 0x0110 << " 0x0110"; + } + { + std::array const expected = { 0x0113, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0112, result.begin()); + EXPECT_EQ(result, expected) << 0x0112 << " 0x0112"; + } + { + std::array const expected = { 0x0115, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0114, result.begin()); + EXPECT_EQ(result, expected) << 0x0114 << " 0x0114"; + } + { + std::array const expected = { 0x0117, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0116, result.begin()); + EXPECT_EQ(result, expected) << 0x0116 << " 0x0116"; + } + { + std::array const expected = { 0x0119, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0118, result.begin()); + EXPECT_EQ(result, expected) << 0x0118 << " 0x0118"; + } + { + std::array const expected = { 0x011B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x011A, result.begin()); + EXPECT_EQ(result, expected) << 0x011A << " 0x011A"; + } + { + std::array const expected = { 0x011D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x011C, result.begin()); + EXPECT_EQ(result, expected) << 0x011C << " 0x011C"; + } + { + std::array const expected = { 0x011F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x011E, result.begin()); + EXPECT_EQ(result, expected) << 0x011E << " 0x011E"; + } + { + std::array const expected = { 0x0121, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0120, result.begin()); + EXPECT_EQ(result, expected) << 0x0120 << " 0x0120"; + } + { + std::array const expected = { 0x0123, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0122, result.begin()); + EXPECT_EQ(result, expected) << 0x0122 << " 0x0122"; + } + { + std::array const expected = { 0x0125, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0124, result.begin()); + EXPECT_EQ(result, expected) << 0x0124 << " 0x0124"; + } + { + std::array const expected = { 0x0127, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0126, result.begin()); + EXPECT_EQ(result, expected) << 0x0126 << " 0x0126"; + } + { + std::array const expected = { 0x0129, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0128, result.begin()); + EXPECT_EQ(result, expected) << 0x0128 << " 0x0128"; + } + { + std::array const expected = { 0x012B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x012A, result.begin()); + EXPECT_EQ(result, expected) << 0x012A << " 0x012A"; + } + { + std::array const expected = { 0x012D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x012C, result.begin()); + EXPECT_EQ(result, expected) << 0x012C << " 0x012C"; + } + { + std::array const expected = { 0x012F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x012E, result.begin()); + EXPECT_EQ(result, expected) << 0x012E << " 0x012E"; + } + { + std::array const expected = { 0x0069, 0x0307, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0130, result.begin()); + EXPECT_EQ(result, expected) << 0x0130 << " 0x0130"; + } + { + std::array const expected = { 0x0133, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0132, result.begin()); + EXPECT_EQ(result, expected) << 0x0132 << " 0x0132"; + } + { + std::array const expected = { 0x0135, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0134, result.begin()); + EXPECT_EQ(result, expected) << 0x0134 << " 0x0134"; + } + { + std::array const expected = { 0x0137, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0136, result.begin()); + EXPECT_EQ(result, expected) << 0x0136 << " 0x0136"; + } + { + std::array const expected = { 0x013A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0139, result.begin()); + EXPECT_EQ(result, expected) << 0x0139 << " 0x0139"; + } + { + std::array const expected = { 0x013C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x013B, result.begin()); + EXPECT_EQ(result, expected) << 0x013B << " 0x013B"; + } + { + std::array const expected = { 0x013E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x013D, result.begin()); + EXPECT_EQ(result, expected) << 0x013D << " 0x013D"; + } + { + std::array const expected = { 0x0140, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x013F, result.begin()); + EXPECT_EQ(result, expected) << 0x013F << " 0x013F"; + } + { + std::array const expected = { 0x0142, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0141, result.begin()); + EXPECT_EQ(result, expected) << 0x0141 << " 0x0141"; + } + { + std::array const expected = { 0x0144, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0143, result.begin()); + EXPECT_EQ(result, expected) << 0x0143 << " 0x0143"; + } + { + std::array const expected = { 0x0146, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0145, result.begin()); + EXPECT_EQ(result, expected) << 0x0145 << " 0x0145"; + } + { + std::array const expected = { 0x0148, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0147, result.begin()); + EXPECT_EQ(result, expected) << 0x0147 << " 0x0147"; + } + { + std::array const expected = { 0x02BC, 0x006E, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0149, result.begin()); + EXPECT_EQ(result, expected) << 0x0149 << " 0x0149"; + } + { + std::array const expected = { 0x014B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x014A, result.begin()); + EXPECT_EQ(result, expected) << 0x014A << " 0x014A"; + } + { + std::array const expected = { 0x014D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x014C, result.begin()); + EXPECT_EQ(result, expected) << 0x014C << " 0x014C"; + } + { + std::array const expected = { 0x014F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x014E, result.begin()); + EXPECT_EQ(result, expected) << 0x014E << " 0x014E"; + } + { + std::array const expected = { 0x0151, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0150, result.begin()); + EXPECT_EQ(result, expected) << 0x0150 << " 0x0150"; + } +} + +TEST(case_folding, test_2) { + { + std::array const expected = { 0x0153, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0152, result.begin()); + EXPECT_EQ(result, expected) << 0x0152 << " 0x0152"; + } + { + std::array const expected = { 0x0155, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0154, result.begin()); + EXPECT_EQ(result, expected) << 0x0154 << " 0x0154"; + } + { + std::array const expected = { 0x0157, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0156, result.begin()); + EXPECT_EQ(result, expected) << 0x0156 << " 0x0156"; + } + { + std::array const expected = { 0x0159, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0158, result.begin()); + EXPECT_EQ(result, expected) << 0x0158 << " 0x0158"; + } + { + std::array const expected = { 0x015B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x015A, result.begin()); + EXPECT_EQ(result, expected) << 0x015A << " 0x015A"; + } + { + std::array const expected = { 0x015D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x015C, result.begin()); + EXPECT_EQ(result, expected) << 0x015C << " 0x015C"; + } + { + std::array const expected = { 0x015F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x015E, result.begin()); + EXPECT_EQ(result, expected) << 0x015E << " 0x015E"; + } + { + std::array const expected = { 0x0161, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0160, result.begin()); + EXPECT_EQ(result, expected) << 0x0160 << " 0x0160"; + } + { + std::array const expected = { 0x0163, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0162, result.begin()); + EXPECT_EQ(result, expected) << 0x0162 << " 0x0162"; + } + { + std::array const expected = { 0x0165, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0164, result.begin()); + EXPECT_EQ(result, expected) << 0x0164 << " 0x0164"; + } + { + std::array const expected = { 0x0167, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0166, result.begin()); + EXPECT_EQ(result, expected) << 0x0166 << " 0x0166"; + } + { + std::array const expected = { 0x0169, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0168, result.begin()); + EXPECT_EQ(result, expected) << 0x0168 << " 0x0168"; + } + { + std::array const expected = { 0x016B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x016A, result.begin()); + EXPECT_EQ(result, expected) << 0x016A << " 0x016A"; + } + { + std::array const expected = { 0x016D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x016C, result.begin()); + EXPECT_EQ(result, expected) << 0x016C << " 0x016C"; + } + { + std::array const expected = { 0x016F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x016E, result.begin()); + EXPECT_EQ(result, expected) << 0x016E << " 0x016E"; + } + { + std::array const expected = { 0x0171, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0170, result.begin()); + EXPECT_EQ(result, expected) << 0x0170 << " 0x0170"; + } + { + std::array const expected = { 0x0173, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0172, result.begin()); + EXPECT_EQ(result, expected) << 0x0172 << " 0x0172"; + } + { + std::array const expected = { 0x0175, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0174, result.begin()); + EXPECT_EQ(result, expected) << 0x0174 << " 0x0174"; + } + { + std::array const expected = { 0x0177, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0176, result.begin()); + EXPECT_EQ(result, expected) << 0x0176 << " 0x0176"; + } + { + std::array const expected = { 0x00FF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0178, result.begin()); + EXPECT_EQ(result, expected) << 0x0178 << " 0x0178"; + } + { + std::array const expected = { 0x017A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0179, result.begin()); + EXPECT_EQ(result, expected) << 0x0179 << " 0x0179"; + } + { + std::array const expected = { 0x017C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x017B, result.begin()); + EXPECT_EQ(result, expected) << 0x017B << " 0x017B"; + } + { + std::array const expected = { 0x017E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x017D, result.begin()); + EXPECT_EQ(result, expected) << 0x017D << " 0x017D"; + } + { + std::array const expected = { 0x0073, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x017F, result.begin()); + EXPECT_EQ(result, expected) << 0x017F << " 0x017F"; + } + { + std::array const expected = { 0x0253, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0181, result.begin()); + EXPECT_EQ(result, expected) << 0x0181 << " 0x0181"; + } + { + std::array const expected = { 0x0183, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0182, result.begin()); + EXPECT_EQ(result, expected) << 0x0182 << " 0x0182"; + } + { + std::array const expected = { 0x0185, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0184, result.begin()); + EXPECT_EQ(result, expected) << 0x0184 << " 0x0184"; + } + { + std::array const expected = { 0x0254, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0186, result.begin()); + EXPECT_EQ(result, expected) << 0x0186 << " 0x0186"; + } + { + std::array const expected = { 0x0188, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0187, result.begin()); + EXPECT_EQ(result, expected) << 0x0187 << " 0x0187"; + } + { + std::array const expected = { 0x0256, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0189, result.begin()); + EXPECT_EQ(result, expected) << 0x0189 << " 0x0189"; + } + { + std::array const expected = { 0x0257, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x018A, result.begin()); + EXPECT_EQ(result, expected) << 0x018A << " 0x018A"; + } + { + std::array const expected = { 0x018C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x018B, result.begin()); + EXPECT_EQ(result, expected) << 0x018B << " 0x018B"; + } + { + std::array const expected = { 0x01DD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x018E, result.begin()); + EXPECT_EQ(result, expected) << 0x018E << " 0x018E"; + } + { + std::array const expected = { 0x0259, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x018F, result.begin()); + EXPECT_EQ(result, expected) << 0x018F << " 0x018F"; + } + { + std::array const expected = { 0x025B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0190, result.begin()); + EXPECT_EQ(result, expected) << 0x0190 << " 0x0190"; + } + { + std::array const expected = { 0x0192, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0191, result.begin()); + EXPECT_EQ(result, expected) << 0x0191 << " 0x0191"; + } + { + std::array const expected = { 0x0260, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0193, result.begin()); + EXPECT_EQ(result, expected) << 0x0193 << " 0x0193"; + } + { + std::array const expected = { 0x0263, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0194, result.begin()); + EXPECT_EQ(result, expected) << 0x0194 << " 0x0194"; + } + { + std::array const expected = { 0x0269, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0196, result.begin()); + EXPECT_EQ(result, expected) << 0x0196 << " 0x0196"; + } + { + std::array const expected = { 0x0268, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0197, result.begin()); + EXPECT_EQ(result, expected) << 0x0197 << " 0x0197"; + } + { + std::array const expected = { 0x0199, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0198, result.begin()); + EXPECT_EQ(result, expected) << 0x0198 << " 0x0198"; + } + { + std::array const expected = { 0x026F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x019C, result.begin()); + EXPECT_EQ(result, expected) << 0x019C << " 0x019C"; + } + { + std::array const expected = { 0x0272, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x019D, result.begin()); + EXPECT_EQ(result, expected) << 0x019D << " 0x019D"; + } + { + std::array const expected = { 0x0275, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x019F, result.begin()); + EXPECT_EQ(result, expected) << 0x019F << " 0x019F"; + } + { + std::array const expected = { 0x01A1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01A0, result.begin()); + EXPECT_EQ(result, expected) << 0x01A0 << " 0x01A0"; + } + { + std::array const expected = { 0x01A3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01A2, result.begin()); + EXPECT_EQ(result, expected) << 0x01A2 << " 0x01A2"; + } + { + std::array const expected = { 0x01A5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01A4, result.begin()); + EXPECT_EQ(result, expected) << 0x01A4 << " 0x01A4"; + } + { + std::array const expected = { 0x0280, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01A6, result.begin()); + EXPECT_EQ(result, expected) << 0x01A6 << " 0x01A6"; + } + { + std::array const expected = { 0x01A8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01A7, result.begin()); + EXPECT_EQ(result, expected) << 0x01A7 << " 0x01A7"; + } + { + std::array const expected = { 0x0283, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01A9, result.begin()); + EXPECT_EQ(result, expected) << 0x01A9 << " 0x01A9"; + } +} + +TEST(case_folding, test_3) { + { + std::array const expected = { 0x01AD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01AC, result.begin()); + EXPECT_EQ(result, expected) << 0x01AC << " 0x01AC"; + } + { + std::array const expected = { 0x0288, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01AE, result.begin()); + EXPECT_EQ(result, expected) << 0x01AE << " 0x01AE"; + } + { + std::array const expected = { 0x01B0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01AF, result.begin()); + EXPECT_EQ(result, expected) << 0x01AF << " 0x01AF"; + } + { + std::array const expected = { 0x028A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01B1, result.begin()); + EXPECT_EQ(result, expected) << 0x01B1 << " 0x01B1"; + } + { + std::array const expected = { 0x028B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01B2, result.begin()); + EXPECT_EQ(result, expected) << 0x01B2 << " 0x01B2"; + } + { + std::array const expected = { 0x01B4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01B3, result.begin()); + EXPECT_EQ(result, expected) << 0x01B3 << " 0x01B3"; + } + { + std::array const expected = { 0x01B6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01B5, result.begin()); + EXPECT_EQ(result, expected) << 0x01B5 << " 0x01B5"; + } + { + std::array const expected = { 0x0292, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01B7, result.begin()); + EXPECT_EQ(result, expected) << 0x01B7 << " 0x01B7"; + } + { + std::array const expected = { 0x01B9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01B8, result.begin()); + EXPECT_EQ(result, expected) << 0x01B8 << " 0x01B8"; + } + { + std::array const expected = { 0x01BD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01BC, result.begin()); + EXPECT_EQ(result, expected) << 0x01BC << " 0x01BC"; + } + { + std::array const expected = { 0x01C6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01C4, result.begin()); + EXPECT_EQ(result, expected) << 0x01C4 << " 0x01C4"; + } + { + std::array const expected = { 0x01C6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01C5, result.begin()); + EXPECT_EQ(result, expected) << 0x01C5 << " 0x01C5"; + } + { + std::array const expected = { 0x01C9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01C7, result.begin()); + EXPECT_EQ(result, expected) << 0x01C7 << " 0x01C7"; + } + { + std::array const expected = { 0x01C9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01C8, result.begin()); + EXPECT_EQ(result, expected) << 0x01C8 << " 0x01C8"; + } + { + std::array const expected = { 0x01CC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01CA, result.begin()); + EXPECT_EQ(result, expected) << 0x01CA << " 0x01CA"; + } + { + std::array const expected = { 0x01CC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01CB, result.begin()); + EXPECT_EQ(result, expected) << 0x01CB << " 0x01CB"; + } + { + std::array const expected = { 0x01CE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01CD, result.begin()); + EXPECT_EQ(result, expected) << 0x01CD << " 0x01CD"; + } + { + std::array const expected = { 0x01D0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01CF, result.begin()); + EXPECT_EQ(result, expected) << 0x01CF << " 0x01CF"; + } + { + std::array const expected = { 0x01D2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01D1, result.begin()); + EXPECT_EQ(result, expected) << 0x01D1 << " 0x01D1"; + } + { + std::array const expected = { 0x01D4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01D3, result.begin()); + EXPECT_EQ(result, expected) << 0x01D3 << " 0x01D3"; + } + { + std::array const expected = { 0x01D6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01D5, result.begin()); + EXPECT_EQ(result, expected) << 0x01D5 << " 0x01D5"; + } + { + std::array const expected = { 0x01D8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01D7, result.begin()); + EXPECT_EQ(result, expected) << 0x01D7 << " 0x01D7"; + } + { + std::array const expected = { 0x01DA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01D9, result.begin()); + EXPECT_EQ(result, expected) << 0x01D9 << " 0x01D9"; + } + { + std::array const expected = { 0x01DC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01DB, result.begin()); + EXPECT_EQ(result, expected) << 0x01DB << " 0x01DB"; + } + { + std::array const expected = { 0x01DF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01DE, result.begin()); + EXPECT_EQ(result, expected) << 0x01DE << " 0x01DE"; + } + { + std::array const expected = { 0x01E1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01E0, result.begin()); + EXPECT_EQ(result, expected) << 0x01E0 << " 0x01E0"; + } + { + std::array const expected = { 0x01E3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01E2, result.begin()); + EXPECT_EQ(result, expected) << 0x01E2 << " 0x01E2"; + } + { + std::array const expected = { 0x01E5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01E4, result.begin()); + EXPECT_EQ(result, expected) << 0x01E4 << " 0x01E4"; + } + { + std::array const expected = { 0x01E7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01E6, result.begin()); + EXPECT_EQ(result, expected) << 0x01E6 << " 0x01E6"; + } + { + std::array const expected = { 0x01E9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01E8, result.begin()); + EXPECT_EQ(result, expected) << 0x01E8 << " 0x01E8"; + } + { + std::array const expected = { 0x01EB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01EA, result.begin()); + EXPECT_EQ(result, expected) << 0x01EA << " 0x01EA"; + } + { + std::array const expected = { 0x01ED, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01EC, result.begin()); + EXPECT_EQ(result, expected) << 0x01EC << " 0x01EC"; + } + { + std::array const expected = { 0x01EF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01EE, result.begin()); + EXPECT_EQ(result, expected) << 0x01EE << " 0x01EE"; + } + { + std::array const expected = { 0x006A, 0x030C, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01F0, result.begin()); + EXPECT_EQ(result, expected) << 0x01F0 << " 0x01F0"; + } + { + std::array const expected = { 0x01F3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01F1, result.begin()); + EXPECT_EQ(result, expected) << 0x01F1 << " 0x01F1"; + } + { + std::array const expected = { 0x01F3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01F2, result.begin()); + EXPECT_EQ(result, expected) << 0x01F2 << " 0x01F2"; + } + { + std::array const expected = { 0x01F5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01F4, result.begin()); + EXPECT_EQ(result, expected) << 0x01F4 << " 0x01F4"; + } + { + std::array const expected = { 0x0195, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01F6, result.begin()); + EXPECT_EQ(result, expected) << 0x01F6 << " 0x01F6"; + } + { + std::array const expected = { 0x01BF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01F7, result.begin()); + EXPECT_EQ(result, expected) << 0x01F7 << " 0x01F7"; + } + { + std::array const expected = { 0x01F9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01F8, result.begin()); + EXPECT_EQ(result, expected) << 0x01F8 << " 0x01F8"; + } + { + std::array const expected = { 0x01FB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01FA, result.begin()); + EXPECT_EQ(result, expected) << 0x01FA << " 0x01FA"; + } + { + std::array const expected = { 0x01FD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01FC, result.begin()); + EXPECT_EQ(result, expected) << 0x01FC << " 0x01FC"; + } + { + std::array const expected = { 0x01FF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x01FE, result.begin()); + EXPECT_EQ(result, expected) << 0x01FE << " 0x01FE"; + } + { + std::array const expected = { 0x0201, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0200, result.begin()); + EXPECT_EQ(result, expected) << 0x0200 << " 0x0200"; + } + { + std::array const expected = { 0x0203, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0202, result.begin()); + EXPECT_EQ(result, expected) << 0x0202 << " 0x0202"; + } + { + std::array const expected = { 0x0205, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0204, result.begin()); + EXPECT_EQ(result, expected) << 0x0204 << " 0x0204"; + } + { + std::array const expected = { 0x0207, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0206, result.begin()); + EXPECT_EQ(result, expected) << 0x0206 << " 0x0206"; + } + { + std::array const expected = { 0x0209, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0208, result.begin()); + EXPECT_EQ(result, expected) << 0x0208 << " 0x0208"; + } + { + std::array const expected = { 0x020B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x020A, result.begin()); + EXPECT_EQ(result, expected) << 0x020A << " 0x020A"; + } + { + std::array const expected = { 0x020D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x020C, result.begin()); + EXPECT_EQ(result, expected) << 0x020C << " 0x020C"; + } +} + +TEST(case_folding, test_4) { + { + std::array const expected = { 0x020F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x020E, result.begin()); + EXPECT_EQ(result, expected) << 0x020E << " 0x020E"; + } + { + std::array const expected = { 0x0211, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0210, result.begin()); + EXPECT_EQ(result, expected) << 0x0210 << " 0x0210"; + } + { + std::array const expected = { 0x0213, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0212, result.begin()); + EXPECT_EQ(result, expected) << 0x0212 << " 0x0212"; + } + { + std::array const expected = { 0x0215, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0214, result.begin()); + EXPECT_EQ(result, expected) << 0x0214 << " 0x0214"; + } + { + std::array const expected = { 0x0217, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0216, result.begin()); + EXPECT_EQ(result, expected) << 0x0216 << " 0x0216"; + } + { + std::array const expected = { 0x0219, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0218, result.begin()); + EXPECT_EQ(result, expected) << 0x0218 << " 0x0218"; + } + { + std::array const expected = { 0x021B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x021A, result.begin()); + EXPECT_EQ(result, expected) << 0x021A << " 0x021A"; + } + { + std::array const expected = { 0x021D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x021C, result.begin()); + EXPECT_EQ(result, expected) << 0x021C << " 0x021C"; + } + { + std::array const expected = { 0x021F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x021E, result.begin()); + EXPECT_EQ(result, expected) << 0x021E << " 0x021E"; + } + { + std::array const expected = { 0x019E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0220, result.begin()); + EXPECT_EQ(result, expected) << 0x0220 << " 0x0220"; + } + { + std::array const expected = { 0x0223, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0222, result.begin()); + EXPECT_EQ(result, expected) << 0x0222 << " 0x0222"; + } + { + std::array const expected = { 0x0225, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0224, result.begin()); + EXPECT_EQ(result, expected) << 0x0224 << " 0x0224"; + } + { + std::array const expected = { 0x0227, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0226, result.begin()); + EXPECT_EQ(result, expected) << 0x0226 << " 0x0226"; + } + { + std::array const expected = { 0x0229, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0228, result.begin()); + EXPECT_EQ(result, expected) << 0x0228 << " 0x0228"; + } + { + std::array const expected = { 0x022B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x022A, result.begin()); + EXPECT_EQ(result, expected) << 0x022A << " 0x022A"; + } + { + std::array const expected = { 0x022D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x022C, result.begin()); + EXPECT_EQ(result, expected) << 0x022C << " 0x022C"; + } + { + std::array const expected = { 0x022F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x022E, result.begin()); + EXPECT_EQ(result, expected) << 0x022E << " 0x022E"; + } + { + std::array const expected = { 0x0231, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0230, result.begin()); + EXPECT_EQ(result, expected) << 0x0230 << " 0x0230"; + } + { + std::array const expected = { 0x0233, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0232, result.begin()); + EXPECT_EQ(result, expected) << 0x0232 << " 0x0232"; + } + { + std::array const expected = { 0x2C65, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x023A, result.begin()); + EXPECT_EQ(result, expected) << 0x023A << " 0x023A"; + } + { + std::array const expected = { 0x023C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x023B, result.begin()); + EXPECT_EQ(result, expected) << 0x023B << " 0x023B"; + } + { + std::array const expected = { 0x019A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x023D, result.begin()); + EXPECT_EQ(result, expected) << 0x023D << " 0x023D"; + } + { + std::array const expected = { 0x2C66, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x023E, result.begin()); + EXPECT_EQ(result, expected) << 0x023E << " 0x023E"; + } + { + std::array const expected = { 0x0242, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0241, result.begin()); + EXPECT_EQ(result, expected) << 0x0241 << " 0x0241"; + } + { + std::array const expected = { 0x0180, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0243, result.begin()); + EXPECT_EQ(result, expected) << 0x0243 << " 0x0243"; + } + { + std::array const expected = { 0x0289, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0244, result.begin()); + EXPECT_EQ(result, expected) << 0x0244 << " 0x0244"; + } + { + std::array const expected = { 0x028C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0245, result.begin()); + EXPECT_EQ(result, expected) << 0x0245 << " 0x0245"; + } + { + std::array const expected = { 0x0247, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0246, result.begin()); + EXPECT_EQ(result, expected) << 0x0246 << " 0x0246"; + } + { + std::array const expected = { 0x0249, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0248, result.begin()); + EXPECT_EQ(result, expected) << 0x0248 << " 0x0248"; + } + { + std::array const expected = { 0x024B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x024A, result.begin()); + EXPECT_EQ(result, expected) << 0x024A << " 0x024A"; + } + { + std::array const expected = { 0x024D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x024C, result.begin()); + EXPECT_EQ(result, expected) << 0x024C << " 0x024C"; + } + { + std::array const expected = { 0x024F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x024E, result.begin()); + EXPECT_EQ(result, expected) << 0x024E << " 0x024E"; + } + { + std::array const expected = { 0x03B9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0345, result.begin()); + EXPECT_EQ(result, expected) << 0x0345 << " 0x0345"; + } + { + std::array const expected = { 0x0371, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0370, result.begin()); + EXPECT_EQ(result, expected) << 0x0370 << " 0x0370"; + } + { + std::array const expected = { 0x0373, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0372, result.begin()); + EXPECT_EQ(result, expected) << 0x0372 << " 0x0372"; + } + { + std::array const expected = { 0x0377, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0376, result.begin()); + EXPECT_EQ(result, expected) << 0x0376 << " 0x0376"; + } + { + std::array const expected = { 0x03F3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x037F, result.begin()); + EXPECT_EQ(result, expected) << 0x037F << " 0x037F"; + } + { + std::array const expected = { 0x03AC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0386, result.begin()); + EXPECT_EQ(result, expected) << 0x0386 << " 0x0386"; + } + { + std::array const expected = { 0x03AD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0388, result.begin()); + EXPECT_EQ(result, expected) << 0x0388 << " 0x0388"; + } + { + std::array const expected = { 0x03AE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0389, result.begin()); + EXPECT_EQ(result, expected) << 0x0389 << " 0x0389"; + } + { + std::array const expected = { 0x03AF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x038A, result.begin()); + EXPECT_EQ(result, expected) << 0x038A << " 0x038A"; + } + { + std::array const expected = { 0x03CC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x038C, result.begin()); + EXPECT_EQ(result, expected) << 0x038C << " 0x038C"; + } + { + std::array const expected = { 0x03CD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x038E, result.begin()); + EXPECT_EQ(result, expected) << 0x038E << " 0x038E"; + } + { + std::array const expected = { 0x03CE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x038F, result.begin()); + EXPECT_EQ(result, expected) << 0x038F << " 0x038F"; + } + { + std::array const expected = { 0x03B9, 0x0308, 0x0301, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0390, result.begin()); + EXPECT_EQ(result, expected) << 0x0390 << " 0x0390"; + } + { + std::array const expected = { 0x03B1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0391, result.begin()); + EXPECT_EQ(result, expected) << 0x0391 << " 0x0391"; + } + { + std::array const expected = { 0x03B2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0392, result.begin()); + EXPECT_EQ(result, expected) << 0x0392 << " 0x0392"; + } + { + std::array const expected = { 0x03B3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0393, result.begin()); + EXPECT_EQ(result, expected) << 0x0393 << " 0x0393"; + } + { + std::array const expected = { 0x03B4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0394, result.begin()); + EXPECT_EQ(result, expected) << 0x0394 << " 0x0394"; + } + { + std::array const expected = { 0x03B5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0395, result.begin()); + EXPECT_EQ(result, expected) << 0x0395 << " 0x0395"; + } +} + +TEST(case_folding, test_5) { + { + std::array const expected = { 0x03B6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0396, result.begin()); + EXPECT_EQ(result, expected) << 0x0396 << " 0x0396"; + } + { + std::array const expected = { 0x03B7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0397, result.begin()); + EXPECT_EQ(result, expected) << 0x0397 << " 0x0397"; + } + { + std::array const expected = { 0x03B8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0398, result.begin()); + EXPECT_EQ(result, expected) << 0x0398 << " 0x0398"; + } + { + std::array const expected = { 0x03B9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0399, result.begin()); + EXPECT_EQ(result, expected) << 0x0399 << " 0x0399"; + } + { + std::array const expected = { 0x03BA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x039A, result.begin()); + EXPECT_EQ(result, expected) << 0x039A << " 0x039A"; + } + { + std::array const expected = { 0x03BB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x039B, result.begin()); + EXPECT_EQ(result, expected) << 0x039B << " 0x039B"; + } + { + std::array const expected = { 0x03BC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x039C, result.begin()); + EXPECT_EQ(result, expected) << 0x039C << " 0x039C"; + } + { + std::array const expected = { 0x03BD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x039D, result.begin()); + EXPECT_EQ(result, expected) << 0x039D << " 0x039D"; + } + { + std::array const expected = { 0x03BE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x039E, result.begin()); + EXPECT_EQ(result, expected) << 0x039E << " 0x039E"; + } + { + std::array const expected = { 0x03BF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x039F, result.begin()); + EXPECT_EQ(result, expected) << 0x039F << " 0x039F"; + } + { + std::array const expected = { 0x03C0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03A0, result.begin()); + EXPECT_EQ(result, expected) << 0x03A0 << " 0x03A0"; + } + { + std::array const expected = { 0x03C1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03A1, result.begin()); + EXPECT_EQ(result, expected) << 0x03A1 << " 0x03A1"; + } + { + std::array const expected = { 0x03C3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03A3, result.begin()); + EXPECT_EQ(result, expected) << 0x03A3 << " 0x03A3"; + } + { + std::array const expected = { 0x03C4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03A4, result.begin()); + EXPECT_EQ(result, expected) << 0x03A4 << " 0x03A4"; + } + { + std::array const expected = { 0x03C5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03A5, result.begin()); + EXPECT_EQ(result, expected) << 0x03A5 << " 0x03A5"; + } + { + std::array const expected = { 0x03C6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03A6, result.begin()); + EXPECT_EQ(result, expected) << 0x03A6 << " 0x03A6"; + } + { + std::array const expected = { 0x03C7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03A7, result.begin()); + EXPECT_EQ(result, expected) << 0x03A7 << " 0x03A7"; + } + { + std::array const expected = { 0x03C8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03A8, result.begin()); + EXPECT_EQ(result, expected) << 0x03A8 << " 0x03A8"; + } + { + std::array const expected = { 0x03C9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03A9, result.begin()); + EXPECT_EQ(result, expected) << 0x03A9 << " 0x03A9"; + } + { + std::array const expected = { 0x03CA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03AA, result.begin()); + EXPECT_EQ(result, expected) << 0x03AA << " 0x03AA"; + } + { + std::array const expected = { 0x03CB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03AB, result.begin()); + EXPECT_EQ(result, expected) << 0x03AB << " 0x03AB"; + } + { + std::array const expected = { 0x03C5, 0x0308, 0x0301, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03B0, result.begin()); + EXPECT_EQ(result, expected) << 0x03B0 << " 0x03B0"; + } + { + std::array const expected = { 0x03C3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03C2, result.begin()); + EXPECT_EQ(result, expected) << 0x03C2 << " 0x03C2"; + } + { + std::array const expected = { 0x03D7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03CF, result.begin()); + EXPECT_EQ(result, expected) << 0x03CF << " 0x03CF"; + } + { + std::array const expected = { 0x03B2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03D0, result.begin()); + EXPECT_EQ(result, expected) << 0x03D0 << " 0x03D0"; + } + { + std::array const expected = { 0x03B8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03D1, result.begin()); + EXPECT_EQ(result, expected) << 0x03D1 << " 0x03D1"; + } + { + std::array const expected = { 0x03C6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03D5, result.begin()); + EXPECT_EQ(result, expected) << 0x03D5 << " 0x03D5"; + } + { + std::array const expected = { 0x03C0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03D6, result.begin()); + EXPECT_EQ(result, expected) << 0x03D6 << " 0x03D6"; + } + { + std::array const expected = { 0x03D9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03D8, result.begin()); + EXPECT_EQ(result, expected) << 0x03D8 << " 0x03D8"; + } + { + std::array const expected = { 0x03DB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03DA, result.begin()); + EXPECT_EQ(result, expected) << 0x03DA << " 0x03DA"; + } + { + std::array const expected = { 0x03DD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03DC, result.begin()); + EXPECT_EQ(result, expected) << 0x03DC << " 0x03DC"; + } + { + std::array const expected = { 0x03DF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03DE, result.begin()); + EXPECT_EQ(result, expected) << 0x03DE << " 0x03DE"; + } + { + std::array const expected = { 0x03E1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03E0, result.begin()); + EXPECT_EQ(result, expected) << 0x03E0 << " 0x03E0"; + } + { + std::array const expected = { 0x03E3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03E2, result.begin()); + EXPECT_EQ(result, expected) << 0x03E2 << " 0x03E2"; + } + { + std::array const expected = { 0x03E5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03E4, result.begin()); + EXPECT_EQ(result, expected) << 0x03E4 << " 0x03E4"; + } + { + std::array const expected = { 0x03E7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03E6, result.begin()); + EXPECT_EQ(result, expected) << 0x03E6 << " 0x03E6"; + } + { + std::array const expected = { 0x03E9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03E8, result.begin()); + EXPECT_EQ(result, expected) << 0x03E8 << " 0x03E8"; + } + { + std::array const expected = { 0x03EB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03EA, result.begin()); + EXPECT_EQ(result, expected) << 0x03EA << " 0x03EA"; + } + { + std::array const expected = { 0x03ED, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03EC, result.begin()); + EXPECT_EQ(result, expected) << 0x03EC << " 0x03EC"; + } + { + std::array const expected = { 0x03EF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03EE, result.begin()); + EXPECT_EQ(result, expected) << 0x03EE << " 0x03EE"; + } + { + std::array const expected = { 0x03BA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03F0, result.begin()); + EXPECT_EQ(result, expected) << 0x03F0 << " 0x03F0"; + } + { + std::array const expected = { 0x03C1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03F1, result.begin()); + EXPECT_EQ(result, expected) << 0x03F1 << " 0x03F1"; + } + { + std::array const expected = { 0x03B8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03F4, result.begin()); + EXPECT_EQ(result, expected) << 0x03F4 << " 0x03F4"; + } + { + std::array const expected = { 0x03B5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03F5, result.begin()); + EXPECT_EQ(result, expected) << 0x03F5 << " 0x03F5"; + } + { + std::array const expected = { 0x03F8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03F7, result.begin()); + EXPECT_EQ(result, expected) << 0x03F7 << " 0x03F7"; + } + { + std::array const expected = { 0x03F2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03F9, result.begin()); + EXPECT_EQ(result, expected) << 0x03F9 << " 0x03F9"; + } + { + std::array const expected = { 0x03FB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03FA, result.begin()); + EXPECT_EQ(result, expected) << 0x03FA << " 0x03FA"; + } + { + std::array const expected = { 0x037B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03FD, result.begin()); + EXPECT_EQ(result, expected) << 0x03FD << " 0x03FD"; + } + { + std::array const expected = { 0x037C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03FE, result.begin()); + EXPECT_EQ(result, expected) << 0x03FE << " 0x03FE"; + } + { + std::array const expected = { 0x037D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x03FF, result.begin()); + EXPECT_EQ(result, expected) << 0x03FF << " 0x03FF"; + } +} + +TEST(case_folding, test_6) { + { + std::array const expected = { 0x0450, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0400, result.begin()); + EXPECT_EQ(result, expected) << 0x0400 << " 0x0400"; + } + { + std::array const expected = { 0x0451, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0401, result.begin()); + EXPECT_EQ(result, expected) << 0x0401 << " 0x0401"; + } + { + std::array const expected = { 0x0452, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0402, result.begin()); + EXPECT_EQ(result, expected) << 0x0402 << " 0x0402"; + } + { + std::array const expected = { 0x0453, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0403, result.begin()); + EXPECT_EQ(result, expected) << 0x0403 << " 0x0403"; + } + { + std::array const expected = { 0x0454, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0404, result.begin()); + EXPECT_EQ(result, expected) << 0x0404 << " 0x0404"; + } + { + std::array const expected = { 0x0455, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0405, result.begin()); + EXPECT_EQ(result, expected) << 0x0405 << " 0x0405"; + } + { + std::array const expected = { 0x0456, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0406, result.begin()); + EXPECT_EQ(result, expected) << 0x0406 << " 0x0406"; + } + { + std::array const expected = { 0x0457, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0407, result.begin()); + EXPECT_EQ(result, expected) << 0x0407 << " 0x0407"; + } + { + std::array const expected = { 0x0458, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0408, result.begin()); + EXPECT_EQ(result, expected) << 0x0408 << " 0x0408"; + } + { + std::array const expected = { 0x0459, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0409, result.begin()); + EXPECT_EQ(result, expected) << 0x0409 << " 0x0409"; + } + { + std::array const expected = { 0x045A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x040A, result.begin()); + EXPECT_EQ(result, expected) << 0x040A << " 0x040A"; + } + { + std::array const expected = { 0x045B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x040B, result.begin()); + EXPECT_EQ(result, expected) << 0x040B << " 0x040B"; + } + { + std::array const expected = { 0x045C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x040C, result.begin()); + EXPECT_EQ(result, expected) << 0x040C << " 0x040C"; + } + { + std::array const expected = { 0x045D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x040D, result.begin()); + EXPECT_EQ(result, expected) << 0x040D << " 0x040D"; + } + { + std::array const expected = { 0x045E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x040E, result.begin()); + EXPECT_EQ(result, expected) << 0x040E << " 0x040E"; + } + { + std::array const expected = { 0x045F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x040F, result.begin()); + EXPECT_EQ(result, expected) << 0x040F << " 0x040F"; + } + { + std::array const expected = { 0x0430, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0410, result.begin()); + EXPECT_EQ(result, expected) << 0x0410 << " 0x0410"; + } + { + std::array const expected = { 0x0431, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0411, result.begin()); + EXPECT_EQ(result, expected) << 0x0411 << " 0x0411"; + } + { + std::array const expected = { 0x0432, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0412, result.begin()); + EXPECT_EQ(result, expected) << 0x0412 << " 0x0412"; + } + { + std::array const expected = { 0x0433, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0413, result.begin()); + EXPECT_EQ(result, expected) << 0x0413 << " 0x0413"; + } + { + std::array const expected = { 0x0434, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0414, result.begin()); + EXPECT_EQ(result, expected) << 0x0414 << " 0x0414"; + } + { + std::array const expected = { 0x0435, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0415, result.begin()); + EXPECT_EQ(result, expected) << 0x0415 << " 0x0415"; + } + { + std::array const expected = { 0x0436, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0416, result.begin()); + EXPECT_EQ(result, expected) << 0x0416 << " 0x0416"; + } + { + std::array const expected = { 0x0437, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0417, result.begin()); + EXPECT_EQ(result, expected) << 0x0417 << " 0x0417"; + } + { + std::array const expected = { 0x0438, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0418, result.begin()); + EXPECT_EQ(result, expected) << 0x0418 << " 0x0418"; + } + { + std::array const expected = { 0x0439, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0419, result.begin()); + EXPECT_EQ(result, expected) << 0x0419 << " 0x0419"; + } + { + std::array const expected = { 0x043A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x041A, result.begin()); + EXPECT_EQ(result, expected) << 0x041A << " 0x041A"; + } + { + std::array const expected = { 0x043B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x041B, result.begin()); + EXPECT_EQ(result, expected) << 0x041B << " 0x041B"; + } + { + std::array const expected = { 0x043C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x041C, result.begin()); + EXPECT_EQ(result, expected) << 0x041C << " 0x041C"; + } + { + std::array const expected = { 0x043D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x041D, result.begin()); + EXPECT_EQ(result, expected) << 0x041D << " 0x041D"; + } + { + std::array const expected = { 0x043E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x041E, result.begin()); + EXPECT_EQ(result, expected) << 0x041E << " 0x041E"; + } + { + std::array const expected = { 0x043F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x041F, result.begin()); + EXPECT_EQ(result, expected) << 0x041F << " 0x041F"; + } + { + std::array const expected = { 0x0440, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0420, result.begin()); + EXPECT_EQ(result, expected) << 0x0420 << " 0x0420"; + } + { + std::array const expected = { 0x0441, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0421, result.begin()); + EXPECT_EQ(result, expected) << 0x0421 << " 0x0421"; + } + { + std::array const expected = { 0x0442, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0422, result.begin()); + EXPECT_EQ(result, expected) << 0x0422 << " 0x0422"; + } + { + std::array const expected = { 0x0443, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0423, result.begin()); + EXPECT_EQ(result, expected) << 0x0423 << " 0x0423"; + } + { + std::array const expected = { 0x0444, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0424, result.begin()); + EXPECT_EQ(result, expected) << 0x0424 << " 0x0424"; + } + { + std::array const expected = { 0x0445, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0425, result.begin()); + EXPECT_EQ(result, expected) << 0x0425 << " 0x0425"; + } + { + std::array const expected = { 0x0446, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0426, result.begin()); + EXPECT_EQ(result, expected) << 0x0426 << " 0x0426"; + } + { + std::array const expected = { 0x0447, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0427, result.begin()); + EXPECT_EQ(result, expected) << 0x0427 << " 0x0427"; + } + { + std::array const expected = { 0x0448, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0428, result.begin()); + EXPECT_EQ(result, expected) << 0x0428 << " 0x0428"; + } + { + std::array const expected = { 0x0449, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0429, result.begin()); + EXPECT_EQ(result, expected) << 0x0429 << " 0x0429"; + } + { + std::array const expected = { 0x044A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x042A, result.begin()); + EXPECT_EQ(result, expected) << 0x042A << " 0x042A"; + } + { + std::array const expected = { 0x044B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x042B, result.begin()); + EXPECT_EQ(result, expected) << 0x042B << " 0x042B"; + } + { + std::array const expected = { 0x044C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x042C, result.begin()); + EXPECT_EQ(result, expected) << 0x042C << " 0x042C"; + } + { + std::array const expected = { 0x044D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x042D, result.begin()); + EXPECT_EQ(result, expected) << 0x042D << " 0x042D"; + } + { + std::array const expected = { 0x044E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x042E, result.begin()); + EXPECT_EQ(result, expected) << 0x042E << " 0x042E"; + } + { + std::array const expected = { 0x044F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x042F, result.begin()); + EXPECT_EQ(result, expected) << 0x042F << " 0x042F"; + } + { + std::array const expected = { 0x0461, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0460, result.begin()); + EXPECT_EQ(result, expected) << 0x0460 << " 0x0460"; + } + { + std::array const expected = { 0x0463, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0462, result.begin()); + EXPECT_EQ(result, expected) << 0x0462 << " 0x0462"; + } +} + +TEST(case_folding, test_7) { + { + std::array const expected = { 0x0465, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0464, result.begin()); + EXPECT_EQ(result, expected) << 0x0464 << " 0x0464"; + } + { + std::array const expected = { 0x0467, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0466, result.begin()); + EXPECT_EQ(result, expected) << 0x0466 << " 0x0466"; + } + { + std::array const expected = { 0x0469, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0468, result.begin()); + EXPECT_EQ(result, expected) << 0x0468 << " 0x0468"; + } + { + std::array const expected = { 0x046B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x046A, result.begin()); + EXPECT_EQ(result, expected) << 0x046A << " 0x046A"; + } + { + std::array const expected = { 0x046D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x046C, result.begin()); + EXPECT_EQ(result, expected) << 0x046C << " 0x046C"; + } + { + std::array const expected = { 0x046F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x046E, result.begin()); + EXPECT_EQ(result, expected) << 0x046E << " 0x046E"; + } + { + std::array const expected = { 0x0471, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0470, result.begin()); + EXPECT_EQ(result, expected) << 0x0470 << " 0x0470"; + } + { + std::array const expected = { 0x0473, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0472, result.begin()); + EXPECT_EQ(result, expected) << 0x0472 << " 0x0472"; + } + { + std::array const expected = { 0x0475, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0474, result.begin()); + EXPECT_EQ(result, expected) << 0x0474 << " 0x0474"; + } + { + std::array const expected = { 0x0477, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0476, result.begin()); + EXPECT_EQ(result, expected) << 0x0476 << " 0x0476"; + } + { + std::array const expected = { 0x0479, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0478, result.begin()); + EXPECT_EQ(result, expected) << 0x0478 << " 0x0478"; + } + { + std::array const expected = { 0x047B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x047A, result.begin()); + EXPECT_EQ(result, expected) << 0x047A << " 0x047A"; + } + { + std::array const expected = { 0x047D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x047C, result.begin()); + EXPECT_EQ(result, expected) << 0x047C << " 0x047C"; + } + { + std::array const expected = { 0x047F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x047E, result.begin()); + EXPECT_EQ(result, expected) << 0x047E << " 0x047E"; + } + { + std::array const expected = { 0x0481, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0480, result.begin()); + EXPECT_EQ(result, expected) << 0x0480 << " 0x0480"; + } + { + std::array const expected = { 0x048B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x048A, result.begin()); + EXPECT_EQ(result, expected) << 0x048A << " 0x048A"; + } + { + std::array const expected = { 0x048D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x048C, result.begin()); + EXPECT_EQ(result, expected) << 0x048C << " 0x048C"; + } + { + std::array const expected = { 0x048F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x048E, result.begin()); + EXPECT_EQ(result, expected) << 0x048E << " 0x048E"; + } + { + std::array const expected = { 0x0491, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0490, result.begin()); + EXPECT_EQ(result, expected) << 0x0490 << " 0x0490"; + } + { + std::array const expected = { 0x0493, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0492, result.begin()); + EXPECT_EQ(result, expected) << 0x0492 << " 0x0492"; + } + { + std::array const expected = { 0x0495, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0494, result.begin()); + EXPECT_EQ(result, expected) << 0x0494 << " 0x0494"; + } + { + std::array const expected = { 0x0497, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0496, result.begin()); + EXPECT_EQ(result, expected) << 0x0496 << " 0x0496"; + } + { + std::array const expected = { 0x0499, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0498, result.begin()); + EXPECT_EQ(result, expected) << 0x0498 << " 0x0498"; + } + { + std::array const expected = { 0x049B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x049A, result.begin()); + EXPECT_EQ(result, expected) << 0x049A << " 0x049A"; + } + { + std::array const expected = { 0x049D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x049C, result.begin()); + EXPECT_EQ(result, expected) << 0x049C << " 0x049C"; + } + { + std::array const expected = { 0x049F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x049E, result.begin()); + EXPECT_EQ(result, expected) << 0x049E << " 0x049E"; + } + { + std::array const expected = { 0x04A1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04A0, result.begin()); + EXPECT_EQ(result, expected) << 0x04A0 << " 0x04A0"; + } + { + std::array const expected = { 0x04A3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04A2, result.begin()); + EXPECT_EQ(result, expected) << 0x04A2 << " 0x04A2"; + } + { + std::array const expected = { 0x04A5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04A4, result.begin()); + EXPECT_EQ(result, expected) << 0x04A4 << " 0x04A4"; + } + { + std::array const expected = { 0x04A7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04A6, result.begin()); + EXPECT_EQ(result, expected) << 0x04A6 << " 0x04A6"; + } + { + std::array const expected = { 0x04A9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04A8, result.begin()); + EXPECT_EQ(result, expected) << 0x04A8 << " 0x04A8"; + } + { + std::array const expected = { 0x04AB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04AA, result.begin()); + EXPECT_EQ(result, expected) << 0x04AA << " 0x04AA"; + } + { + std::array const expected = { 0x04AD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04AC, result.begin()); + EXPECT_EQ(result, expected) << 0x04AC << " 0x04AC"; + } + { + std::array const expected = { 0x04AF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04AE, result.begin()); + EXPECT_EQ(result, expected) << 0x04AE << " 0x04AE"; + } + { + std::array const expected = { 0x04B1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04B0, result.begin()); + EXPECT_EQ(result, expected) << 0x04B0 << " 0x04B0"; + } + { + std::array const expected = { 0x04B3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04B2, result.begin()); + EXPECT_EQ(result, expected) << 0x04B2 << " 0x04B2"; + } + { + std::array const expected = { 0x04B5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04B4, result.begin()); + EXPECT_EQ(result, expected) << 0x04B4 << " 0x04B4"; + } + { + std::array const expected = { 0x04B7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04B6, result.begin()); + EXPECT_EQ(result, expected) << 0x04B6 << " 0x04B6"; + } + { + std::array const expected = { 0x04B9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04B8, result.begin()); + EXPECT_EQ(result, expected) << 0x04B8 << " 0x04B8"; + } + { + std::array const expected = { 0x04BB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04BA, result.begin()); + EXPECT_EQ(result, expected) << 0x04BA << " 0x04BA"; + } + { + std::array const expected = { 0x04BD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04BC, result.begin()); + EXPECT_EQ(result, expected) << 0x04BC << " 0x04BC"; + } + { + std::array const expected = { 0x04BF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04BE, result.begin()); + EXPECT_EQ(result, expected) << 0x04BE << " 0x04BE"; + } + { + std::array const expected = { 0x04CF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04C0, result.begin()); + EXPECT_EQ(result, expected) << 0x04C0 << " 0x04C0"; + } + { + std::array const expected = { 0x04C2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04C1, result.begin()); + EXPECT_EQ(result, expected) << 0x04C1 << " 0x04C1"; + } + { + std::array const expected = { 0x04C4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04C3, result.begin()); + EXPECT_EQ(result, expected) << 0x04C3 << " 0x04C3"; + } + { + std::array const expected = { 0x04C6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04C5, result.begin()); + EXPECT_EQ(result, expected) << 0x04C5 << " 0x04C5"; + } + { + std::array const expected = { 0x04C8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04C7, result.begin()); + EXPECT_EQ(result, expected) << 0x04C7 << " 0x04C7"; + } + { + std::array const expected = { 0x04CA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04C9, result.begin()); + EXPECT_EQ(result, expected) << 0x04C9 << " 0x04C9"; + } + { + std::array const expected = { 0x04CC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04CB, result.begin()); + EXPECT_EQ(result, expected) << 0x04CB << " 0x04CB"; + } + { + std::array const expected = { 0x04CE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04CD, result.begin()); + EXPECT_EQ(result, expected) << 0x04CD << " 0x04CD"; + } +} + +TEST(case_folding, test_8) { + { + std::array const expected = { 0x04D1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04D0, result.begin()); + EXPECT_EQ(result, expected) << 0x04D0 << " 0x04D0"; + } + { + std::array const expected = { 0x04D3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04D2, result.begin()); + EXPECT_EQ(result, expected) << 0x04D2 << " 0x04D2"; + } + { + std::array const expected = { 0x04D5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04D4, result.begin()); + EXPECT_EQ(result, expected) << 0x04D4 << " 0x04D4"; + } + { + std::array const expected = { 0x04D7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04D6, result.begin()); + EXPECT_EQ(result, expected) << 0x04D6 << " 0x04D6"; + } + { + std::array const expected = { 0x04D9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04D8, result.begin()); + EXPECT_EQ(result, expected) << 0x04D8 << " 0x04D8"; + } + { + std::array const expected = { 0x04DB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04DA, result.begin()); + EXPECT_EQ(result, expected) << 0x04DA << " 0x04DA"; + } + { + std::array const expected = { 0x04DD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04DC, result.begin()); + EXPECT_EQ(result, expected) << 0x04DC << " 0x04DC"; + } + { + std::array const expected = { 0x04DF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04DE, result.begin()); + EXPECT_EQ(result, expected) << 0x04DE << " 0x04DE"; + } + { + std::array const expected = { 0x04E1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04E0, result.begin()); + EXPECT_EQ(result, expected) << 0x04E0 << " 0x04E0"; + } + { + std::array const expected = { 0x04E3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04E2, result.begin()); + EXPECT_EQ(result, expected) << 0x04E2 << " 0x04E2"; + } + { + std::array const expected = { 0x04E5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04E4, result.begin()); + EXPECT_EQ(result, expected) << 0x04E4 << " 0x04E4"; + } + { + std::array const expected = { 0x04E7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04E6, result.begin()); + EXPECT_EQ(result, expected) << 0x04E6 << " 0x04E6"; + } + { + std::array const expected = { 0x04E9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04E8, result.begin()); + EXPECT_EQ(result, expected) << 0x04E8 << " 0x04E8"; + } + { + std::array const expected = { 0x04EB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04EA, result.begin()); + EXPECT_EQ(result, expected) << 0x04EA << " 0x04EA"; + } + { + std::array const expected = { 0x04ED, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04EC, result.begin()); + EXPECT_EQ(result, expected) << 0x04EC << " 0x04EC"; + } + { + std::array const expected = { 0x04EF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04EE, result.begin()); + EXPECT_EQ(result, expected) << 0x04EE << " 0x04EE"; + } + { + std::array const expected = { 0x04F1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04F0, result.begin()); + EXPECT_EQ(result, expected) << 0x04F0 << " 0x04F0"; + } + { + std::array const expected = { 0x04F3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04F2, result.begin()); + EXPECT_EQ(result, expected) << 0x04F2 << " 0x04F2"; + } + { + std::array const expected = { 0x04F5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04F4, result.begin()); + EXPECT_EQ(result, expected) << 0x04F4 << " 0x04F4"; + } + { + std::array const expected = { 0x04F7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04F6, result.begin()); + EXPECT_EQ(result, expected) << 0x04F6 << " 0x04F6"; + } + { + std::array const expected = { 0x04F9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04F8, result.begin()); + EXPECT_EQ(result, expected) << 0x04F8 << " 0x04F8"; + } + { + std::array const expected = { 0x04FB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04FA, result.begin()); + EXPECT_EQ(result, expected) << 0x04FA << " 0x04FA"; + } + { + std::array const expected = { 0x04FD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04FC, result.begin()); + EXPECT_EQ(result, expected) << 0x04FC << " 0x04FC"; + } + { + std::array const expected = { 0x04FF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x04FE, result.begin()); + EXPECT_EQ(result, expected) << 0x04FE << " 0x04FE"; + } + { + std::array const expected = { 0x0501, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0500, result.begin()); + EXPECT_EQ(result, expected) << 0x0500 << " 0x0500"; + } + { + std::array const expected = { 0x0503, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0502, result.begin()); + EXPECT_EQ(result, expected) << 0x0502 << " 0x0502"; + } + { + std::array const expected = { 0x0505, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0504, result.begin()); + EXPECT_EQ(result, expected) << 0x0504 << " 0x0504"; + } + { + std::array const expected = { 0x0507, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0506, result.begin()); + EXPECT_EQ(result, expected) << 0x0506 << " 0x0506"; + } + { + std::array const expected = { 0x0509, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0508, result.begin()); + EXPECT_EQ(result, expected) << 0x0508 << " 0x0508"; + } + { + std::array const expected = { 0x050B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x050A, result.begin()); + EXPECT_EQ(result, expected) << 0x050A << " 0x050A"; + } + { + std::array const expected = { 0x050D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x050C, result.begin()); + EXPECT_EQ(result, expected) << 0x050C << " 0x050C"; + } + { + std::array const expected = { 0x050F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x050E, result.begin()); + EXPECT_EQ(result, expected) << 0x050E << " 0x050E"; + } + { + std::array const expected = { 0x0511, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0510, result.begin()); + EXPECT_EQ(result, expected) << 0x0510 << " 0x0510"; + } + { + std::array const expected = { 0x0513, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0512, result.begin()); + EXPECT_EQ(result, expected) << 0x0512 << " 0x0512"; + } + { + std::array const expected = { 0x0515, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0514, result.begin()); + EXPECT_EQ(result, expected) << 0x0514 << " 0x0514"; + } + { + std::array const expected = { 0x0517, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0516, result.begin()); + EXPECT_EQ(result, expected) << 0x0516 << " 0x0516"; + } + { + std::array const expected = { 0x0519, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0518, result.begin()); + EXPECT_EQ(result, expected) << 0x0518 << " 0x0518"; + } + { + std::array const expected = { 0x051B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x051A, result.begin()); + EXPECT_EQ(result, expected) << 0x051A << " 0x051A"; + } + { + std::array const expected = { 0x051D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x051C, result.begin()); + EXPECT_EQ(result, expected) << 0x051C << " 0x051C"; + } + { + std::array const expected = { 0x051F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x051E, result.begin()); + EXPECT_EQ(result, expected) << 0x051E << " 0x051E"; + } + { + std::array const expected = { 0x0521, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0520, result.begin()); + EXPECT_EQ(result, expected) << 0x0520 << " 0x0520"; + } + { + std::array const expected = { 0x0523, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0522, result.begin()); + EXPECT_EQ(result, expected) << 0x0522 << " 0x0522"; + } + { + std::array const expected = { 0x0525, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0524, result.begin()); + EXPECT_EQ(result, expected) << 0x0524 << " 0x0524"; + } + { + std::array const expected = { 0x0527, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0526, result.begin()); + EXPECT_EQ(result, expected) << 0x0526 << " 0x0526"; + } + { + std::array const expected = { 0x0529, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0528, result.begin()); + EXPECT_EQ(result, expected) << 0x0528 << " 0x0528"; + } + { + std::array const expected = { 0x052B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x052A, result.begin()); + EXPECT_EQ(result, expected) << 0x052A << " 0x052A"; + } + { + std::array const expected = { 0x052D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x052C, result.begin()); + EXPECT_EQ(result, expected) << 0x052C << " 0x052C"; + } + { + std::array const expected = { 0x052F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x052E, result.begin()); + EXPECT_EQ(result, expected) << 0x052E << " 0x052E"; + } + { + std::array const expected = { 0x0561, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0531, result.begin()); + EXPECT_EQ(result, expected) << 0x0531 << " 0x0531"; + } + { + std::array const expected = { 0x0562, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0532, result.begin()); + EXPECT_EQ(result, expected) << 0x0532 << " 0x0532"; + } +} + +TEST(case_folding, test_9) { + { + std::array const expected = { 0x0563, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0533, result.begin()); + EXPECT_EQ(result, expected) << 0x0533 << " 0x0533"; + } + { + std::array const expected = { 0x0564, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0534, result.begin()); + EXPECT_EQ(result, expected) << 0x0534 << " 0x0534"; + } + { + std::array const expected = { 0x0565, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0535, result.begin()); + EXPECT_EQ(result, expected) << 0x0535 << " 0x0535"; + } + { + std::array const expected = { 0x0566, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0536, result.begin()); + EXPECT_EQ(result, expected) << 0x0536 << " 0x0536"; + } + { + std::array const expected = { 0x0567, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0537, result.begin()); + EXPECT_EQ(result, expected) << 0x0537 << " 0x0537"; + } + { + std::array const expected = { 0x0568, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0538, result.begin()); + EXPECT_EQ(result, expected) << 0x0538 << " 0x0538"; + } + { + std::array const expected = { 0x0569, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0539, result.begin()); + EXPECT_EQ(result, expected) << 0x0539 << " 0x0539"; + } + { + std::array const expected = { 0x056A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x053A, result.begin()); + EXPECT_EQ(result, expected) << 0x053A << " 0x053A"; + } + { + std::array const expected = { 0x056B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x053B, result.begin()); + EXPECT_EQ(result, expected) << 0x053B << " 0x053B"; + } + { + std::array const expected = { 0x056C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x053C, result.begin()); + EXPECT_EQ(result, expected) << 0x053C << " 0x053C"; + } + { + std::array const expected = { 0x056D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x053D, result.begin()); + EXPECT_EQ(result, expected) << 0x053D << " 0x053D"; + } + { + std::array const expected = { 0x056E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x053E, result.begin()); + EXPECT_EQ(result, expected) << 0x053E << " 0x053E"; + } + { + std::array const expected = { 0x056F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x053F, result.begin()); + EXPECT_EQ(result, expected) << 0x053F << " 0x053F"; + } + { + std::array const expected = { 0x0570, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0540, result.begin()); + EXPECT_EQ(result, expected) << 0x0540 << " 0x0540"; + } + { + std::array const expected = { 0x0571, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0541, result.begin()); + EXPECT_EQ(result, expected) << 0x0541 << " 0x0541"; + } + { + std::array const expected = { 0x0572, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0542, result.begin()); + EXPECT_EQ(result, expected) << 0x0542 << " 0x0542"; + } + { + std::array const expected = { 0x0573, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0543, result.begin()); + EXPECT_EQ(result, expected) << 0x0543 << " 0x0543"; + } + { + std::array const expected = { 0x0574, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0544, result.begin()); + EXPECT_EQ(result, expected) << 0x0544 << " 0x0544"; + } + { + std::array const expected = { 0x0575, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0545, result.begin()); + EXPECT_EQ(result, expected) << 0x0545 << " 0x0545"; + } + { + std::array const expected = { 0x0576, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0546, result.begin()); + EXPECT_EQ(result, expected) << 0x0546 << " 0x0546"; + } + { + std::array const expected = { 0x0577, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0547, result.begin()); + EXPECT_EQ(result, expected) << 0x0547 << " 0x0547"; + } + { + std::array const expected = { 0x0578, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0548, result.begin()); + EXPECT_EQ(result, expected) << 0x0548 << " 0x0548"; + } + { + std::array const expected = { 0x0579, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0549, result.begin()); + EXPECT_EQ(result, expected) << 0x0549 << " 0x0549"; + } + { + std::array const expected = { 0x057A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x054A, result.begin()); + EXPECT_EQ(result, expected) << 0x054A << " 0x054A"; + } + { + std::array const expected = { 0x057B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x054B, result.begin()); + EXPECT_EQ(result, expected) << 0x054B << " 0x054B"; + } + { + std::array const expected = { 0x057C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x054C, result.begin()); + EXPECT_EQ(result, expected) << 0x054C << " 0x054C"; + } + { + std::array const expected = { 0x057D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x054D, result.begin()); + EXPECT_EQ(result, expected) << 0x054D << " 0x054D"; + } + { + std::array const expected = { 0x057E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x054E, result.begin()); + EXPECT_EQ(result, expected) << 0x054E << " 0x054E"; + } + { + std::array const expected = { 0x057F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x054F, result.begin()); + EXPECT_EQ(result, expected) << 0x054F << " 0x054F"; + } + { + std::array const expected = { 0x0580, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0550, result.begin()); + EXPECT_EQ(result, expected) << 0x0550 << " 0x0550"; + } + { + std::array const expected = { 0x0581, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0551, result.begin()); + EXPECT_EQ(result, expected) << 0x0551 << " 0x0551"; + } + { + std::array const expected = { 0x0582, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0552, result.begin()); + EXPECT_EQ(result, expected) << 0x0552 << " 0x0552"; + } + { + std::array const expected = { 0x0583, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0553, result.begin()); + EXPECT_EQ(result, expected) << 0x0553 << " 0x0553"; + } + { + std::array const expected = { 0x0584, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0554, result.begin()); + EXPECT_EQ(result, expected) << 0x0554 << " 0x0554"; + } + { + std::array const expected = { 0x0585, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0555, result.begin()); + EXPECT_EQ(result, expected) << 0x0555 << " 0x0555"; + } + { + std::array const expected = { 0x0586, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0556, result.begin()); + EXPECT_EQ(result, expected) << 0x0556 << " 0x0556"; + } + { + std::array const expected = { 0x0565, 0x0582, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x0587, result.begin()); + EXPECT_EQ(result, expected) << 0x0587 << " 0x0587"; + } + { + std::array const expected = { 0x2D00, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10A0, result.begin()); + EXPECT_EQ(result, expected) << 0x10A0 << " 0x10A0"; + } + { + std::array const expected = { 0x2D01, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10A1, result.begin()); + EXPECT_EQ(result, expected) << 0x10A1 << " 0x10A1"; + } + { + std::array const expected = { 0x2D02, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10A2, result.begin()); + EXPECT_EQ(result, expected) << 0x10A2 << " 0x10A2"; + } + { + std::array const expected = { 0x2D03, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10A3, result.begin()); + EXPECT_EQ(result, expected) << 0x10A3 << " 0x10A3"; + } + { + std::array const expected = { 0x2D04, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10A4, result.begin()); + EXPECT_EQ(result, expected) << 0x10A4 << " 0x10A4"; + } + { + std::array const expected = { 0x2D05, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10A5, result.begin()); + EXPECT_EQ(result, expected) << 0x10A5 << " 0x10A5"; + } + { + std::array const expected = { 0x2D06, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10A6, result.begin()); + EXPECT_EQ(result, expected) << 0x10A6 << " 0x10A6"; + } + { + std::array const expected = { 0x2D07, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10A7, result.begin()); + EXPECT_EQ(result, expected) << 0x10A7 << " 0x10A7"; + } + { + std::array const expected = { 0x2D08, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10A8, result.begin()); + EXPECT_EQ(result, expected) << 0x10A8 << " 0x10A8"; + } + { + std::array const expected = { 0x2D09, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10A9, result.begin()); + EXPECT_EQ(result, expected) << 0x10A9 << " 0x10A9"; + } + { + std::array const expected = { 0x2D0A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10AA, result.begin()); + EXPECT_EQ(result, expected) << 0x10AA << " 0x10AA"; + } + { + std::array const expected = { 0x2D0B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10AB, result.begin()); + EXPECT_EQ(result, expected) << 0x10AB << " 0x10AB"; + } + { + std::array const expected = { 0x2D0C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10AC, result.begin()); + EXPECT_EQ(result, expected) << 0x10AC << " 0x10AC"; + } +} + +TEST(case_folding, test_10) { + { + std::array const expected = { 0x2D0D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10AD, result.begin()); + EXPECT_EQ(result, expected) << 0x10AD << " 0x10AD"; + } + { + std::array const expected = { 0x2D0E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10AE, result.begin()); + EXPECT_EQ(result, expected) << 0x10AE << " 0x10AE"; + } + { + std::array const expected = { 0x2D0F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10AF, result.begin()); + EXPECT_EQ(result, expected) << 0x10AF << " 0x10AF"; + } + { + std::array const expected = { 0x2D10, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10B0, result.begin()); + EXPECT_EQ(result, expected) << 0x10B0 << " 0x10B0"; + } + { + std::array const expected = { 0x2D11, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10B1, result.begin()); + EXPECT_EQ(result, expected) << 0x10B1 << " 0x10B1"; + } + { + std::array const expected = { 0x2D12, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10B2, result.begin()); + EXPECT_EQ(result, expected) << 0x10B2 << " 0x10B2"; + } + { + std::array const expected = { 0x2D13, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10B3, result.begin()); + EXPECT_EQ(result, expected) << 0x10B3 << " 0x10B3"; + } + { + std::array const expected = { 0x2D14, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10B4, result.begin()); + EXPECT_EQ(result, expected) << 0x10B4 << " 0x10B4"; + } + { + std::array const expected = { 0x2D15, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10B5, result.begin()); + EXPECT_EQ(result, expected) << 0x10B5 << " 0x10B5"; + } + { + std::array const expected = { 0x2D16, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10B6, result.begin()); + EXPECT_EQ(result, expected) << 0x10B6 << " 0x10B6"; + } + { + std::array const expected = { 0x2D17, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10B7, result.begin()); + EXPECT_EQ(result, expected) << 0x10B7 << " 0x10B7"; + } + { + std::array const expected = { 0x2D18, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10B8, result.begin()); + EXPECT_EQ(result, expected) << 0x10B8 << " 0x10B8"; + } + { + std::array const expected = { 0x2D19, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10B9, result.begin()); + EXPECT_EQ(result, expected) << 0x10B9 << " 0x10B9"; + } + { + std::array const expected = { 0x2D1A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10BA, result.begin()); + EXPECT_EQ(result, expected) << 0x10BA << " 0x10BA"; + } + { + std::array const expected = { 0x2D1B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10BB, result.begin()); + EXPECT_EQ(result, expected) << 0x10BB << " 0x10BB"; + } + { + std::array const expected = { 0x2D1C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10BC, result.begin()); + EXPECT_EQ(result, expected) << 0x10BC << " 0x10BC"; + } + { + std::array const expected = { 0x2D1D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10BD, result.begin()); + EXPECT_EQ(result, expected) << 0x10BD << " 0x10BD"; + } + { + std::array const expected = { 0x2D1E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10BE, result.begin()); + EXPECT_EQ(result, expected) << 0x10BE << " 0x10BE"; + } + { + std::array const expected = { 0x2D1F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10BF, result.begin()); + EXPECT_EQ(result, expected) << 0x10BF << " 0x10BF"; + } + { + std::array const expected = { 0x2D20, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C0, result.begin()); + EXPECT_EQ(result, expected) << 0x10C0 << " 0x10C0"; + } + { + std::array const expected = { 0x2D21, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C1, result.begin()); + EXPECT_EQ(result, expected) << 0x10C1 << " 0x10C1"; + } + { + std::array const expected = { 0x2D22, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C2, result.begin()); + EXPECT_EQ(result, expected) << 0x10C2 << " 0x10C2"; + } + { + std::array const expected = { 0x2D23, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C3, result.begin()); + EXPECT_EQ(result, expected) << 0x10C3 << " 0x10C3"; + } + { + std::array const expected = { 0x2D24, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C4, result.begin()); + EXPECT_EQ(result, expected) << 0x10C4 << " 0x10C4"; + } + { + std::array const expected = { 0x2D25, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C5, result.begin()); + EXPECT_EQ(result, expected) << 0x10C5 << " 0x10C5"; + } + { + std::array const expected = { 0x2D27, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C7, result.begin()); + EXPECT_EQ(result, expected) << 0x10C7 << " 0x10C7"; + } + { + std::array const expected = { 0x2D2D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CD, result.begin()); + EXPECT_EQ(result, expected) << 0x10CD << " 0x10CD"; + } + { + std::array const expected = { 0x13F0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x13F8, result.begin()); + EXPECT_EQ(result, expected) << 0x13F8 << " 0x13F8"; + } + { + std::array const expected = { 0x13F1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x13F9, result.begin()); + EXPECT_EQ(result, expected) << 0x13F9 << " 0x13F9"; + } + { + std::array const expected = { 0x13F2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x13FA, result.begin()); + EXPECT_EQ(result, expected) << 0x13FA << " 0x13FA"; + } + { + std::array const expected = { 0x13F3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x13FB, result.begin()); + EXPECT_EQ(result, expected) << 0x13FB << " 0x13FB"; + } + { + std::array const expected = { 0x13F4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x13FC, result.begin()); + EXPECT_EQ(result, expected) << 0x13FC << " 0x13FC"; + } + { + std::array const expected = { 0x13F5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x13FD, result.begin()); + EXPECT_EQ(result, expected) << 0x13FD << " 0x13FD"; + } + { + std::array const expected = { 0x0432, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C80, result.begin()); + EXPECT_EQ(result, expected) << 0x1C80 << " 0x1C80"; + } + { + std::array const expected = { 0x0434, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C81, result.begin()); + EXPECT_EQ(result, expected) << 0x1C81 << " 0x1C81"; + } + { + std::array const expected = { 0x043E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C82, result.begin()); + EXPECT_EQ(result, expected) << 0x1C82 << " 0x1C82"; + } + { + std::array const expected = { 0x0441, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C83, result.begin()); + EXPECT_EQ(result, expected) << 0x1C83 << " 0x1C83"; + } + { + std::array const expected = { 0x0442, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C84, result.begin()); + EXPECT_EQ(result, expected) << 0x1C84 << " 0x1C84"; + } + { + std::array const expected = { 0x0442, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C85, result.begin()); + EXPECT_EQ(result, expected) << 0x1C85 << " 0x1C85"; + } + { + std::array const expected = { 0x044A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C86, result.begin()); + EXPECT_EQ(result, expected) << 0x1C86 << " 0x1C86"; + } + { + std::array const expected = { 0x0463, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C87, result.begin()); + EXPECT_EQ(result, expected) << 0x1C87 << " 0x1C87"; + } + { + std::array const expected = { 0xA64B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C88, result.begin()); + EXPECT_EQ(result, expected) << 0x1C88 << " 0x1C88"; + } + { + std::array const expected = { 0x10D0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C90, result.begin()); + EXPECT_EQ(result, expected) << 0x1C90 << " 0x1C90"; + } + { + std::array const expected = { 0x10D1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C91, result.begin()); + EXPECT_EQ(result, expected) << 0x1C91 << " 0x1C91"; + } + { + std::array const expected = { 0x10D2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C92, result.begin()); + EXPECT_EQ(result, expected) << 0x1C92 << " 0x1C92"; + } + { + std::array const expected = { 0x10D3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C93, result.begin()); + EXPECT_EQ(result, expected) << 0x1C93 << " 0x1C93"; + } + { + std::array const expected = { 0x10D4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C94, result.begin()); + EXPECT_EQ(result, expected) << 0x1C94 << " 0x1C94"; + } + { + std::array const expected = { 0x10D5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C95, result.begin()); + EXPECT_EQ(result, expected) << 0x1C95 << " 0x1C95"; + } + { + std::array const expected = { 0x10D6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C96, result.begin()); + EXPECT_EQ(result, expected) << 0x1C96 << " 0x1C96"; + } + { + std::array const expected = { 0x10D7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C97, result.begin()); + EXPECT_EQ(result, expected) << 0x1C97 << " 0x1C97"; + } +} + +TEST(case_folding, test_11) { + { + std::array const expected = { 0x10D8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C98, result.begin()); + EXPECT_EQ(result, expected) << 0x1C98 << " 0x1C98"; + } + { + std::array const expected = { 0x10D9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C99, result.begin()); + EXPECT_EQ(result, expected) << 0x1C99 << " 0x1C99"; + } + { + std::array const expected = { 0x10DA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C9A, result.begin()); + EXPECT_EQ(result, expected) << 0x1C9A << " 0x1C9A"; + } + { + std::array const expected = { 0x10DB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C9B, result.begin()); + EXPECT_EQ(result, expected) << 0x1C9B << " 0x1C9B"; + } + { + std::array const expected = { 0x10DC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C9C, result.begin()); + EXPECT_EQ(result, expected) << 0x1C9C << " 0x1C9C"; + } + { + std::array const expected = { 0x10DD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C9D, result.begin()); + EXPECT_EQ(result, expected) << 0x1C9D << " 0x1C9D"; + } + { + std::array const expected = { 0x10DE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C9E, result.begin()); + EXPECT_EQ(result, expected) << 0x1C9E << " 0x1C9E"; + } + { + std::array const expected = { 0x10DF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1C9F, result.begin()); + EXPECT_EQ(result, expected) << 0x1C9F << " 0x1C9F"; + } + { + std::array const expected = { 0x10E0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CA0, result.begin()); + EXPECT_EQ(result, expected) << 0x1CA0 << " 0x1CA0"; + } + { + std::array const expected = { 0x10E1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CA1, result.begin()); + EXPECT_EQ(result, expected) << 0x1CA1 << " 0x1CA1"; + } + { + std::array const expected = { 0x10E2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CA2, result.begin()); + EXPECT_EQ(result, expected) << 0x1CA2 << " 0x1CA2"; + } + { + std::array const expected = { 0x10E3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CA3, result.begin()); + EXPECT_EQ(result, expected) << 0x1CA3 << " 0x1CA3"; + } + { + std::array const expected = { 0x10E4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CA4, result.begin()); + EXPECT_EQ(result, expected) << 0x1CA4 << " 0x1CA4"; + } + { + std::array const expected = { 0x10E5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CA5, result.begin()); + EXPECT_EQ(result, expected) << 0x1CA5 << " 0x1CA5"; + } + { + std::array const expected = { 0x10E6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CA6, result.begin()); + EXPECT_EQ(result, expected) << 0x1CA6 << " 0x1CA6"; + } + { + std::array const expected = { 0x10E7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CA7, result.begin()); + EXPECT_EQ(result, expected) << 0x1CA7 << " 0x1CA7"; + } + { + std::array const expected = { 0x10E8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CA8, result.begin()); + EXPECT_EQ(result, expected) << 0x1CA8 << " 0x1CA8"; + } + { + std::array const expected = { 0x10E9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CA9, result.begin()); + EXPECT_EQ(result, expected) << 0x1CA9 << " 0x1CA9"; + } + { + std::array const expected = { 0x10EA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CAA, result.begin()); + EXPECT_EQ(result, expected) << 0x1CAA << " 0x1CAA"; + } + { + std::array const expected = { 0x10EB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CAB, result.begin()); + EXPECT_EQ(result, expected) << 0x1CAB << " 0x1CAB"; + } + { + std::array const expected = { 0x10EC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CAC, result.begin()); + EXPECT_EQ(result, expected) << 0x1CAC << " 0x1CAC"; + } + { + std::array const expected = { 0x10ED, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CAD, result.begin()); + EXPECT_EQ(result, expected) << 0x1CAD << " 0x1CAD"; + } + { + std::array const expected = { 0x10EE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CAE, result.begin()); + EXPECT_EQ(result, expected) << 0x1CAE << " 0x1CAE"; + } + { + std::array const expected = { 0x10EF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CAF, result.begin()); + EXPECT_EQ(result, expected) << 0x1CAF << " 0x1CAF"; + } + { + std::array const expected = { 0x10F0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CB0, result.begin()); + EXPECT_EQ(result, expected) << 0x1CB0 << " 0x1CB0"; + } + { + std::array const expected = { 0x10F1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CB1, result.begin()); + EXPECT_EQ(result, expected) << 0x1CB1 << " 0x1CB1"; + } + { + std::array const expected = { 0x10F2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CB2, result.begin()); + EXPECT_EQ(result, expected) << 0x1CB2 << " 0x1CB2"; + } + { + std::array const expected = { 0x10F3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CB3, result.begin()); + EXPECT_EQ(result, expected) << 0x1CB3 << " 0x1CB3"; + } + { + std::array const expected = { 0x10F4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CB4, result.begin()); + EXPECT_EQ(result, expected) << 0x1CB4 << " 0x1CB4"; + } + { + std::array const expected = { 0x10F5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CB5, result.begin()); + EXPECT_EQ(result, expected) << 0x1CB5 << " 0x1CB5"; + } + { + std::array const expected = { 0x10F6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CB6, result.begin()); + EXPECT_EQ(result, expected) << 0x1CB6 << " 0x1CB6"; + } + { + std::array const expected = { 0x10F7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CB7, result.begin()); + EXPECT_EQ(result, expected) << 0x1CB7 << " 0x1CB7"; + } + { + std::array const expected = { 0x10F8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CB8, result.begin()); + EXPECT_EQ(result, expected) << 0x1CB8 << " 0x1CB8"; + } + { + std::array const expected = { 0x10F9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CB9, result.begin()); + EXPECT_EQ(result, expected) << 0x1CB9 << " 0x1CB9"; + } + { + std::array const expected = { 0x10FA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CBA, result.begin()); + EXPECT_EQ(result, expected) << 0x1CBA << " 0x1CBA"; + } + { + std::array const expected = { 0x10FD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CBD, result.begin()); + EXPECT_EQ(result, expected) << 0x1CBD << " 0x1CBD"; + } + { + std::array const expected = { 0x10FE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CBE, result.begin()); + EXPECT_EQ(result, expected) << 0x1CBE << " 0x1CBE"; + } + { + std::array const expected = { 0x10FF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1CBF, result.begin()); + EXPECT_EQ(result, expected) << 0x1CBF << " 0x1CBF"; + } + { + std::array const expected = { 0x1E01, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E00, result.begin()); + EXPECT_EQ(result, expected) << 0x1E00 << " 0x1E00"; + } + { + std::array const expected = { 0x1E03, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E02, result.begin()); + EXPECT_EQ(result, expected) << 0x1E02 << " 0x1E02"; + } + { + std::array const expected = { 0x1E05, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E04, result.begin()); + EXPECT_EQ(result, expected) << 0x1E04 << " 0x1E04"; + } + { + std::array const expected = { 0x1E07, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E06, result.begin()); + EXPECT_EQ(result, expected) << 0x1E06 << " 0x1E06"; + } + { + std::array const expected = { 0x1E09, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E08, result.begin()); + EXPECT_EQ(result, expected) << 0x1E08 << " 0x1E08"; + } + { + std::array const expected = { 0x1E0B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E0A, result.begin()); + EXPECT_EQ(result, expected) << 0x1E0A << " 0x1E0A"; + } + { + std::array const expected = { 0x1E0D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E0C, result.begin()); + EXPECT_EQ(result, expected) << 0x1E0C << " 0x1E0C"; + } + { + std::array const expected = { 0x1E0F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E0E, result.begin()); + EXPECT_EQ(result, expected) << 0x1E0E << " 0x1E0E"; + } + { + std::array const expected = { 0x1E11, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E10, result.begin()); + EXPECT_EQ(result, expected) << 0x1E10 << " 0x1E10"; + } + { + std::array const expected = { 0x1E13, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E12, result.begin()); + EXPECT_EQ(result, expected) << 0x1E12 << " 0x1E12"; + } + { + std::array const expected = { 0x1E15, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E14, result.begin()); + EXPECT_EQ(result, expected) << 0x1E14 << " 0x1E14"; + } + { + std::array const expected = { 0x1E17, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E16, result.begin()); + EXPECT_EQ(result, expected) << 0x1E16 << " 0x1E16"; + } +} + +TEST(case_folding, test_12) { + { + std::array const expected = { 0x1E19, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E18, result.begin()); + EXPECT_EQ(result, expected) << 0x1E18 << " 0x1E18"; + } + { + std::array const expected = { 0x1E1B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E1A, result.begin()); + EXPECT_EQ(result, expected) << 0x1E1A << " 0x1E1A"; + } + { + std::array const expected = { 0x1E1D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E1C, result.begin()); + EXPECT_EQ(result, expected) << 0x1E1C << " 0x1E1C"; + } + { + std::array const expected = { 0x1E1F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E1E, result.begin()); + EXPECT_EQ(result, expected) << 0x1E1E << " 0x1E1E"; + } + { + std::array const expected = { 0x1E21, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E20, result.begin()); + EXPECT_EQ(result, expected) << 0x1E20 << " 0x1E20"; + } + { + std::array const expected = { 0x1E23, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E22, result.begin()); + EXPECT_EQ(result, expected) << 0x1E22 << " 0x1E22"; + } + { + std::array const expected = { 0x1E25, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E24, result.begin()); + EXPECT_EQ(result, expected) << 0x1E24 << " 0x1E24"; + } + { + std::array const expected = { 0x1E27, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E26, result.begin()); + EXPECT_EQ(result, expected) << 0x1E26 << " 0x1E26"; + } + { + std::array const expected = { 0x1E29, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E28, result.begin()); + EXPECT_EQ(result, expected) << 0x1E28 << " 0x1E28"; + } + { + std::array const expected = { 0x1E2B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E2A, result.begin()); + EXPECT_EQ(result, expected) << 0x1E2A << " 0x1E2A"; + } + { + std::array const expected = { 0x1E2D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E2C, result.begin()); + EXPECT_EQ(result, expected) << 0x1E2C << " 0x1E2C"; + } + { + std::array const expected = { 0x1E2F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E2E, result.begin()); + EXPECT_EQ(result, expected) << 0x1E2E << " 0x1E2E"; + } + { + std::array const expected = { 0x1E31, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E30, result.begin()); + EXPECT_EQ(result, expected) << 0x1E30 << " 0x1E30"; + } + { + std::array const expected = { 0x1E33, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E32, result.begin()); + EXPECT_EQ(result, expected) << 0x1E32 << " 0x1E32"; + } + { + std::array const expected = { 0x1E35, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E34, result.begin()); + EXPECT_EQ(result, expected) << 0x1E34 << " 0x1E34"; + } + { + std::array const expected = { 0x1E37, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E36, result.begin()); + EXPECT_EQ(result, expected) << 0x1E36 << " 0x1E36"; + } + { + std::array const expected = { 0x1E39, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E38, result.begin()); + EXPECT_EQ(result, expected) << 0x1E38 << " 0x1E38"; + } + { + std::array const expected = { 0x1E3B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E3A, result.begin()); + EXPECT_EQ(result, expected) << 0x1E3A << " 0x1E3A"; + } + { + std::array const expected = { 0x1E3D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E3C, result.begin()); + EXPECT_EQ(result, expected) << 0x1E3C << " 0x1E3C"; + } + { + std::array const expected = { 0x1E3F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E3E, result.begin()); + EXPECT_EQ(result, expected) << 0x1E3E << " 0x1E3E"; + } + { + std::array const expected = { 0x1E41, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E40, result.begin()); + EXPECT_EQ(result, expected) << 0x1E40 << " 0x1E40"; + } + { + std::array const expected = { 0x1E43, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E42, result.begin()); + EXPECT_EQ(result, expected) << 0x1E42 << " 0x1E42"; + } + { + std::array const expected = { 0x1E45, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E44, result.begin()); + EXPECT_EQ(result, expected) << 0x1E44 << " 0x1E44"; + } + { + std::array const expected = { 0x1E47, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E46, result.begin()); + EXPECT_EQ(result, expected) << 0x1E46 << " 0x1E46"; + } + { + std::array const expected = { 0x1E49, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E48, result.begin()); + EXPECT_EQ(result, expected) << 0x1E48 << " 0x1E48"; + } + { + std::array const expected = { 0x1E4B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E4A, result.begin()); + EXPECT_EQ(result, expected) << 0x1E4A << " 0x1E4A"; + } + { + std::array const expected = { 0x1E4D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E4C, result.begin()); + EXPECT_EQ(result, expected) << 0x1E4C << " 0x1E4C"; + } + { + std::array const expected = { 0x1E4F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E4E, result.begin()); + EXPECT_EQ(result, expected) << 0x1E4E << " 0x1E4E"; + } + { + std::array const expected = { 0x1E51, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E50, result.begin()); + EXPECT_EQ(result, expected) << 0x1E50 << " 0x1E50"; + } + { + std::array const expected = { 0x1E53, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E52, result.begin()); + EXPECT_EQ(result, expected) << 0x1E52 << " 0x1E52"; + } + { + std::array const expected = { 0x1E55, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E54, result.begin()); + EXPECT_EQ(result, expected) << 0x1E54 << " 0x1E54"; + } + { + std::array const expected = { 0x1E57, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E56, result.begin()); + EXPECT_EQ(result, expected) << 0x1E56 << " 0x1E56"; + } + { + std::array const expected = { 0x1E59, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E58, result.begin()); + EXPECT_EQ(result, expected) << 0x1E58 << " 0x1E58"; + } + { + std::array const expected = { 0x1E5B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E5A, result.begin()); + EXPECT_EQ(result, expected) << 0x1E5A << " 0x1E5A"; + } + { + std::array const expected = { 0x1E5D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E5C, result.begin()); + EXPECT_EQ(result, expected) << 0x1E5C << " 0x1E5C"; + } + { + std::array const expected = { 0x1E5F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E5E, result.begin()); + EXPECT_EQ(result, expected) << 0x1E5E << " 0x1E5E"; + } + { + std::array const expected = { 0x1E61, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E60, result.begin()); + EXPECT_EQ(result, expected) << 0x1E60 << " 0x1E60"; + } + { + std::array const expected = { 0x1E63, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E62, result.begin()); + EXPECT_EQ(result, expected) << 0x1E62 << " 0x1E62"; + } + { + std::array const expected = { 0x1E65, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E64, result.begin()); + EXPECT_EQ(result, expected) << 0x1E64 << " 0x1E64"; + } + { + std::array const expected = { 0x1E67, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E66, result.begin()); + EXPECT_EQ(result, expected) << 0x1E66 << " 0x1E66"; + } + { + std::array const expected = { 0x1E69, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E68, result.begin()); + EXPECT_EQ(result, expected) << 0x1E68 << " 0x1E68"; + } + { + std::array const expected = { 0x1E6B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E6A, result.begin()); + EXPECT_EQ(result, expected) << 0x1E6A << " 0x1E6A"; + } + { + std::array const expected = { 0x1E6D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E6C, result.begin()); + EXPECT_EQ(result, expected) << 0x1E6C << " 0x1E6C"; + } + { + std::array const expected = { 0x1E6F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E6E, result.begin()); + EXPECT_EQ(result, expected) << 0x1E6E << " 0x1E6E"; + } + { + std::array const expected = { 0x1E71, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E70, result.begin()); + EXPECT_EQ(result, expected) << 0x1E70 << " 0x1E70"; + } + { + std::array const expected = { 0x1E73, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E72, result.begin()); + EXPECT_EQ(result, expected) << 0x1E72 << " 0x1E72"; + } + { + std::array const expected = { 0x1E75, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E74, result.begin()); + EXPECT_EQ(result, expected) << 0x1E74 << " 0x1E74"; + } + { + std::array const expected = { 0x1E77, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E76, result.begin()); + EXPECT_EQ(result, expected) << 0x1E76 << " 0x1E76"; + } + { + std::array const expected = { 0x1E79, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E78, result.begin()); + EXPECT_EQ(result, expected) << 0x1E78 << " 0x1E78"; + } + { + std::array const expected = { 0x1E7B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E7A, result.begin()); + EXPECT_EQ(result, expected) << 0x1E7A << " 0x1E7A"; + } +} + +TEST(case_folding, test_13) { + { + std::array const expected = { 0x1E7D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E7C, result.begin()); + EXPECT_EQ(result, expected) << 0x1E7C << " 0x1E7C"; + } + { + std::array const expected = { 0x1E7F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E7E, result.begin()); + EXPECT_EQ(result, expected) << 0x1E7E << " 0x1E7E"; + } + { + std::array const expected = { 0x1E81, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E80, result.begin()); + EXPECT_EQ(result, expected) << 0x1E80 << " 0x1E80"; + } + { + std::array const expected = { 0x1E83, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E82, result.begin()); + EXPECT_EQ(result, expected) << 0x1E82 << " 0x1E82"; + } + { + std::array const expected = { 0x1E85, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E84, result.begin()); + EXPECT_EQ(result, expected) << 0x1E84 << " 0x1E84"; + } + { + std::array const expected = { 0x1E87, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E86, result.begin()); + EXPECT_EQ(result, expected) << 0x1E86 << " 0x1E86"; + } + { + std::array const expected = { 0x1E89, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E88, result.begin()); + EXPECT_EQ(result, expected) << 0x1E88 << " 0x1E88"; + } + { + std::array const expected = { 0x1E8B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E8A, result.begin()); + EXPECT_EQ(result, expected) << 0x1E8A << " 0x1E8A"; + } + { + std::array const expected = { 0x1E8D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E8C, result.begin()); + EXPECT_EQ(result, expected) << 0x1E8C << " 0x1E8C"; + } + { + std::array const expected = { 0x1E8F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E8E, result.begin()); + EXPECT_EQ(result, expected) << 0x1E8E << " 0x1E8E"; + } + { + std::array const expected = { 0x1E91, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E90, result.begin()); + EXPECT_EQ(result, expected) << 0x1E90 << " 0x1E90"; + } + { + std::array const expected = { 0x1E93, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E92, result.begin()); + EXPECT_EQ(result, expected) << 0x1E92 << " 0x1E92"; + } + { + std::array const expected = { 0x1E95, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E94, result.begin()); + EXPECT_EQ(result, expected) << 0x1E94 << " 0x1E94"; + } + { + std::array const expected = { 0x0068, 0x0331, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E96, result.begin()); + EXPECT_EQ(result, expected) << 0x1E96 << " 0x1E96"; + } + { + std::array const expected = { 0x0074, 0x0308, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E97, result.begin()); + EXPECT_EQ(result, expected) << 0x1E97 << " 0x1E97"; + } + { + std::array const expected = { 0x0077, 0x030A, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E98, result.begin()); + EXPECT_EQ(result, expected) << 0x1E98 << " 0x1E98"; + } + { + std::array const expected = { 0x0079, 0x030A, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E99, result.begin()); + EXPECT_EQ(result, expected) << 0x1E99 << " 0x1E99"; + } + { + std::array const expected = { 0x0061, 0x02BE, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E9A, result.begin()); + EXPECT_EQ(result, expected) << 0x1E9A << " 0x1E9A"; + } + { + std::array const expected = { 0x1E61, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E9B, result.begin()); + EXPECT_EQ(result, expected) << 0x1E9B << " 0x1E9B"; + } + { + std::array const expected = { 0x0073, 0x0073, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E9E, result.begin()); + EXPECT_EQ(result, expected) << 0x1E9E << " 0x1E9E"; + } + { + std::array const expected = { 0x1EA1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EA0, result.begin()); + EXPECT_EQ(result, expected) << 0x1EA0 << " 0x1EA0"; + } + { + std::array const expected = { 0x1EA3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EA2, result.begin()); + EXPECT_EQ(result, expected) << 0x1EA2 << " 0x1EA2"; + } + { + std::array const expected = { 0x1EA5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EA4, result.begin()); + EXPECT_EQ(result, expected) << 0x1EA4 << " 0x1EA4"; + } + { + std::array const expected = { 0x1EA7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EA6, result.begin()); + EXPECT_EQ(result, expected) << 0x1EA6 << " 0x1EA6"; + } + { + std::array const expected = { 0x1EA9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EA8, result.begin()); + EXPECT_EQ(result, expected) << 0x1EA8 << " 0x1EA8"; + } + { + std::array const expected = { 0x1EAB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EAA, result.begin()); + EXPECT_EQ(result, expected) << 0x1EAA << " 0x1EAA"; + } + { + std::array const expected = { 0x1EAD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EAC, result.begin()); + EXPECT_EQ(result, expected) << 0x1EAC << " 0x1EAC"; + } + { + std::array const expected = { 0x1EAF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EAE, result.begin()); + EXPECT_EQ(result, expected) << 0x1EAE << " 0x1EAE"; + } + { + std::array const expected = { 0x1EB1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EB0, result.begin()); + EXPECT_EQ(result, expected) << 0x1EB0 << " 0x1EB0"; + } + { + std::array const expected = { 0x1EB3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EB2, result.begin()); + EXPECT_EQ(result, expected) << 0x1EB2 << " 0x1EB2"; + } + { + std::array const expected = { 0x1EB5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EB4, result.begin()); + EXPECT_EQ(result, expected) << 0x1EB4 << " 0x1EB4"; + } + { + std::array const expected = { 0x1EB7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EB6, result.begin()); + EXPECT_EQ(result, expected) << 0x1EB6 << " 0x1EB6"; + } + { + std::array const expected = { 0x1EB9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EB8, result.begin()); + EXPECT_EQ(result, expected) << 0x1EB8 << " 0x1EB8"; + } + { + std::array const expected = { 0x1EBB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EBA, result.begin()); + EXPECT_EQ(result, expected) << 0x1EBA << " 0x1EBA"; + } + { + std::array const expected = { 0x1EBD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EBC, result.begin()); + EXPECT_EQ(result, expected) << 0x1EBC << " 0x1EBC"; + } + { + std::array const expected = { 0x1EBF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EBE, result.begin()); + EXPECT_EQ(result, expected) << 0x1EBE << " 0x1EBE"; + } + { + std::array const expected = { 0x1EC1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EC0, result.begin()); + EXPECT_EQ(result, expected) << 0x1EC0 << " 0x1EC0"; + } + { + std::array const expected = { 0x1EC3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EC2, result.begin()); + EXPECT_EQ(result, expected) << 0x1EC2 << " 0x1EC2"; + } + { + std::array const expected = { 0x1EC5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EC4, result.begin()); + EXPECT_EQ(result, expected) << 0x1EC4 << " 0x1EC4"; + } + { + std::array const expected = { 0x1EC7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EC6, result.begin()); + EXPECT_EQ(result, expected) << 0x1EC6 << " 0x1EC6"; + } + { + std::array const expected = { 0x1EC9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EC8, result.begin()); + EXPECT_EQ(result, expected) << 0x1EC8 << " 0x1EC8"; + } + { + std::array const expected = { 0x1ECB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1ECA, result.begin()); + EXPECT_EQ(result, expected) << 0x1ECA << " 0x1ECA"; + } + { + std::array const expected = { 0x1ECD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1ECC, result.begin()); + EXPECT_EQ(result, expected) << 0x1ECC << " 0x1ECC"; + } + { + std::array const expected = { 0x1ECF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1ECE, result.begin()); + EXPECT_EQ(result, expected) << 0x1ECE << " 0x1ECE"; + } + { + std::array const expected = { 0x1ED1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1ED0, result.begin()); + EXPECT_EQ(result, expected) << 0x1ED0 << " 0x1ED0"; + } + { + std::array const expected = { 0x1ED3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1ED2, result.begin()); + EXPECT_EQ(result, expected) << 0x1ED2 << " 0x1ED2"; + } + { + std::array const expected = { 0x1ED5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1ED4, result.begin()); + EXPECT_EQ(result, expected) << 0x1ED4 << " 0x1ED4"; + } + { + std::array const expected = { 0x1ED7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1ED6, result.begin()); + EXPECT_EQ(result, expected) << 0x1ED6 << " 0x1ED6"; + } + { + std::array const expected = { 0x1ED9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1ED8, result.begin()); + EXPECT_EQ(result, expected) << 0x1ED8 << " 0x1ED8"; + } + { + std::array const expected = { 0x1EDB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EDA, result.begin()); + EXPECT_EQ(result, expected) << 0x1EDA << " 0x1EDA"; + } +} + +TEST(case_folding, test_14) { + { + std::array const expected = { 0x1EDD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EDC, result.begin()); + EXPECT_EQ(result, expected) << 0x1EDC << " 0x1EDC"; + } + { + std::array const expected = { 0x1EDF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EDE, result.begin()); + EXPECT_EQ(result, expected) << 0x1EDE << " 0x1EDE"; + } + { + std::array const expected = { 0x1EE1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EE0, result.begin()); + EXPECT_EQ(result, expected) << 0x1EE0 << " 0x1EE0"; + } + { + std::array const expected = { 0x1EE3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EE2, result.begin()); + EXPECT_EQ(result, expected) << 0x1EE2 << " 0x1EE2"; + } + { + std::array const expected = { 0x1EE5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EE4, result.begin()); + EXPECT_EQ(result, expected) << 0x1EE4 << " 0x1EE4"; + } + { + std::array const expected = { 0x1EE7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EE6, result.begin()); + EXPECT_EQ(result, expected) << 0x1EE6 << " 0x1EE6"; + } + { + std::array const expected = { 0x1EE9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EE8, result.begin()); + EXPECT_EQ(result, expected) << 0x1EE8 << " 0x1EE8"; + } + { + std::array const expected = { 0x1EEB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EEA, result.begin()); + EXPECT_EQ(result, expected) << 0x1EEA << " 0x1EEA"; + } + { + std::array const expected = { 0x1EED, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EEC, result.begin()); + EXPECT_EQ(result, expected) << 0x1EEC << " 0x1EEC"; + } + { + std::array const expected = { 0x1EEF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EEE, result.begin()); + EXPECT_EQ(result, expected) << 0x1EEE << " 0x1EEE"; + } + { + std::array const expected = { 0x1EF1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EF0, result.begin()); + EXPECT_EQ(result, expected) << 0x1EF0 << " 0x1EF0"; + } + { + std::array const expected = { 0x1EF3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EF2, result.begin()); + EXPECT_EQ(result, expected) << 0x1EF2 << " 0x1EF2"; + } + { + std::array const expected = { 0x1EF5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EF4, result.begin()); + EXPECT_EQ(result, expected) << 0x1EF4 << " 0x1EF4"; + } + { + std::array const expected = { 0x1EF7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EF6, result.begin()); + EXPECT_EQ(result, expected) << 0x1EF6 << " 0x1EF6"; + } + { + std::array const expected = { 0x1EF9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EF8, result.begin()); + EXPECT_EQ(result, expected) << 0x1EF8 << " 0x1EF8"; + } + { + std::array const expected = { 0x1EFB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EFA, result.begin()); + EXPECT_EQ(result, expected) << 0x1EFA << " 0x1EFA"; + } + { + std::array const expected = { 0x1EFD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EFC, result.begin()); + EXPECT_EQ(result, expected) << 0x1EFC << " 0x1EFC"; + } + { + std::array const expected = { 0x1EFF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1EFE, result.begin()); + EXPECT_EQ(result, expected) << 0x1EFE << " 0x1EFE"; + } + { + std::array const expected = { 0x1F00, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F08, result.begin()); + EXPECT_EQ(result, expected) << 0x1F08 << " 0x1F08"; + } + { + std::array const expected = { 0x1F01, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F09, result.begin()); + EXPECT_EQ(result, expected) << 0x1F09 << " 0x1F09"; + } + { + std::array const expected = { 0x1F02, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F0A, result.begin()); + EXPECT_EQ(result, expected) << 0x1F0A << " 0x1F0A"; + } + { + std::array const expected = { 0x1F03, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F0B, result.begin()); + EXPECT_EQ(result, expected) << 0x1F0B << " 0x1F0B"; + } + { + std::array const expected = { 0x1F04, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F0C, result.begin()); + EXPECT_EQ(result, expected) << 0x1F0C << " 0x1F0C"; + } + { + std::array const expected = { 0x1F05, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F0D, result.begin()); + EXPECT_EQ(result, expected) << 0x1F0D << " 0x1F0D"; + } + { + std::array const expected = { 0x1F06, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F0E, result.begin()); + EXPECT_EQ(result, expected) << 0x1F0E << " 0x1F0E"; + } + { + std::array const expected = { 0x1F07, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F0F, result.begin()); + EXPECT_EQ(result, expected) << 0x1F0F << " 0x1F0F"; + } + { + std::array const expected = { 0x1F10, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F18, result.begin()); + EXPECT_EQ(result, expected) << 0x1F18 << " 0x1F18"; + } + { + std::array const expected = { 0x1F11, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F19, result.begin()); + EXPECT_EQ(result, expected) << 0x1F19 << " 0x1F19"; + } + { + std::array const expected = { 0x1F12, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F1A, result.begin()); + EXPECT_EQ(result, expected) << 0x1F1A << " 0x1F1A"; + } + { + std::array const expected = { 0x1F13, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F1B, result.begin()); + EXPECT_EQ(result, expected) << 0x1F1B << " 0x1F1B"; + } + { + std::array const expected = { 0x1F14, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F1C, result.begin()); + EXPECT_EQ(result, expected) << 0x1F1C << " 0x1F1C"; + } + { + std::array const expected = { 0x1F15, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F1D, result.begin()); + EXPECT_EQ(result, expected) << 0x1F1D << " 0x1F1D"; + } + { + std::array const expected = { 0x1F20, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F28, result.begin()); + EXPECT_EQ(result, expected) << 0x1F28 << " 0x1F28"; + } + { + std::array const expected = { 0x1F21, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F29, result.begin()); + EXPECT_EQ(result, expected) << 0x1F29 << " 0x1F29"; + } + { + std::array const expected = { 0x1F22, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F2A, result.begin()); + EXPECT_EQ(result, expected) << 0x1F2A << " 0x1F2A"; + } + { + std::array const expected = { 0x1F23, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F2B, result.begin()); + EXPECT_EQ(result, expected) << 0x1F2B << " 0x1F2B"; + } + { + std::array const expected = { 0x1F24, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F2C, result.begin()); + EXPECT_EQ(result, expected) << 0x1F2C << " 0x1F2C"; + } + { + std::array const expected = { 0x1F25, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F2D, result.begin()); + EXPECT_EQ(result, expected) << 0x1F2D << " 0x1F2D"; + } + { + std::array const expected = { 0x1F26, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F2E, result.begin()); + EXPECT_EQ(result, expected) << 0x1F2E << " 0x1F2E"; + } + { + std::array const expected = { 0x1F27, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F2F, result.begin()); + EXPECT_EQ(result, expected) << 0x1F2F << " 0x1F2F"; + } + { + std::array const expected = { 0x1F30, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F38, result.begin()); + EXPECT_EQ(result, expected) << 0x1F38 << " 0x1F38"; + } + { + std::array const expected = { 0x1F31, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F39, result.begin()); + EXPECT_EQ(result, expected) << 0x1F39 << " 0x1F39"; + } + { + std::array const expected = { 0x1F32, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F3A, result.begin()); + EXPECT_EQ(result, expected) << 0x1F3A << " 0x1F3A"; + } + { + std::array const expected = { 0x1F33, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F3B, result.begin()); + EXPECT_EQ(result, expected) << 0x1F3B << " 0x1F3B"; + } + { + std::array const expected = { 0x1F34, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F3C, result.begin()); + EXPECT_EQ(result, expected) << 0x1F3C << " 0x1F3C"; + } + { + std::array const expected = { 0x1F35, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F3D, result.begin()); + EXPECT_EQ(result, expected) << 0x1F3D << " 0x1F3D"; + } + { + std::array const expected = { 0x1F36, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F3E, result.begin()); + EXPECT_EQ(result, expected) << 0x1F3E << " 0x1F3E"; + } + { + std::array const expected = { 0x1F37, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F3F, result.begin()); + EXPECT_EQ(result, expected) << 0x1F3F << " 0x1F3F"; + } + { + std::array const expected = { 0x1F40, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F48, result.begin()); + EXPECT_EQ(result, expected) << 0x1F48 << " 0x1F48"; + } + { + std::array const expected = { 0x1F41, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F49, result.begin()); + EXPECT_EQ(result, expected) << 0x1F49 << " 0x1F49"; + } +} + +TEST(case_folding, test_15) { + { + std::array const expected = { 0x1F42, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F4A, result.begin()); + EXPECT_EQ(result, expected) << 0x1F4A << " 0x1F4A"; + } + { + std::array const expected = { 0x1F43, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F4B, result.begin()); + EXPECT_EQ(result, expected) << 0x1F4B << " 0x1F4B"; + } + { + std::array const expected = { 0x1F44, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F4C, result.begin()); + EXPECT_EQ(result, expected) << 0x1F4C << " 0x1F4C"; + } + { + std::array const expected = { 0x1F45, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F4D, result.begin()); + EXPECT_EQ(result, expected) << 0x1F4D << " 0x1F4D"; + } + { + std::array const expected = { 0x03C5, 0x0313, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F50, result.begin()); + EXPECT_EQ(result, expected) << 0x1F50 << " 0x1F50"; + } + { + std::array const expected = { 0x03C5, 0x0313, 0x0300, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F52, result.begin()); + EXPECT_EQ(result, expected) << 0x1F52 << " 0x1F52"; + } + { + std::array const expected = { 0x03C5, 0x0313, 0x0301, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F54, result.begin()); + EXPECT_EQ(result, expected) << 0x1F54 << " 0x1F54"; + } + { + std::array const expected = { 0x03C5, 0x0313, 0x0342, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F56, result.begin()); + EXPECT_EQ(result, expected) << 0x1F56 << " 0x1F56"; + } + { + std::array const expected = { 0x1F51, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F59, result.begin()); + EXPECT_EQ(result, expected) << 0x1F59 << " 0x1F59"; + } + { + std::array const expected = { 0x1F53, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F5B, result.begin()); + EXPECT_EQ(result, expected) << 0x1F5B << " 0x1F5B"; + } + { + std::array const expected = { 0x1F55, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F5D, result.begin()); + EXPECT_EQ(result, expected) << 0x1F5D << " 0x1F5D"; + } + { + std::array const expected = { 0x1F57, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F5F, result.begin()); + EXPECT_EQ(result, expected) << 0x1F5F << " 0x1F5F"; + } + { + std::array const expected = { 0x1F60, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F68, result.begin()); + EXPECT_EQ(result, expected) << 0x1F68 << " 0x1F68"; + } + { + std::array const expected = { 0x1F61, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F69, result.begin()); + EXPECT_EQ(result, expected) << 0x1F69 << " 0x1F69"; + } + { + std::array const expected = { 0x1F62, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F6A, result.begin()); + EXPECT_EQ(result, expected) << 0x1F6A << " 0x1F6A"; + } + { + std::array const expected = { 0x1F63, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F6B, result.begin()); + EXPECT_EQ(result, expected) << 0x1F6B << " 0x1F6B"; + } + { + std::array const expected = { 0x1F64, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F6C, result.begin()); + EXPECT_EQ(result, expected) << 0x1F6C << " 0x1F6C"; + } + { + std::array const expected = { 0x1F65, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F6D, result.begin()); + EXPECT_EQ(result, expected) << 0x1F6D << " 0x1F6D"; + } + { + std::array const expected = { 0x1F66, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F6E, result.begin()); + EXPECT_EQ(result, expected) << 0x1F6E << " 0x1F6E"; + } + { + std::array const expected = { 0x1F67, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F6F, result.begin()); + EXPECT_EQ(result, expected) << 0x1F6F << " 0x1F6F"; + } + { + std::array const expected = { 0x1F00, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F80, result.begin()); + EXPECT_EQ(result, expected) << 0x1F80 << " 0x1F80"; + } + { + std::array const expected = { 0x1F01, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F81, result.begin()); + EXPECT_EQ(result, expected) << 0x1F81 << " 0x1F81"; + } + { + std::array const expected = { 0x1F02, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F82, result.begin()); + EXPECT_EQ(result, expected) << 0x1F82 << " 0x1F82"; + } + { + std::array const expected = { 0x1F03, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F83, result.begin()); + EXPECT_EQ(result, expected) << 0x1F83 << " 0x1F83"; + } + { + std::array const expected = { 0x1F04, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F84, result.begin()); + EXPECT_EQ(result, expected) << 0x1F84 << " 0x1F84"; + } + { + std::array const expected = { 0x1F05, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F85, result.begin()); + EXPECT_EQ(result, expected) << 0x1F85 << " 0x1F85"; + } + { + std::array const expected = { 0x1F06, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F86, result.begin()); + EXPECT_EQ(result, expected) << 0x1F86 << " 0x1F86"; + } + { + std::array const expected = { 0x1F07, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F87, result.begin()); + EXPECT_EQ(result, expected) << 0x1F87 << " 0x1F87"; + } + { + std::array const expected = { 0x1F00, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F88, result.begin()); + EXPECT_EQ(result, expected) << 0x1F88 << " 0x1F88"; + } + { + std::array const expected = { 0x1F01, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F89, result.begin()); + EXPECT_EQ(result, expected) << 0x1F89 << " 0x1F89"; + } + { + std::array const expected = { 0x1F02, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F8A, result.begin()); + EXPECT_EQ(result, expected) << 0x1F8A << " 0x1F8A"; + } + { + std::array const expected = { 0x1F03, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F8B, result.begin()); + EXPECT_EQ(result, expected) << 0x1F8B << " 0x1F8B"; + } + { + std::array const expected = { 0x1F04, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F8C, result.begin()); + EXPECT_EQ(result, expected) << 0x1F8C << " 0x1F8C"; + } + { + std::array const expected = { 0x1F05, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F8D, result.begin()); + EXPECT_EQ(result, expected) << 0x1F8D << " 0x1F8D"; + } + { + std::array const expected = { 0x1F06, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F8E, result.begin()); + EXPECT_EQ(result, expected) << 0x1F8E << " 0x1F8E"; + } + { + std::array const expected = { 0x1F07, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F8F, result.begin()); + EXPECT_EQ(result, expected) << 0x1F8F << " 0x1F8F"; + } + { + std::array const expected = { 0x1F20, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F90, result.begin()); + EXPECT_EQ(result, expected) << 0x1F90 << " 0x1F90"; + } + { + std::array const expected = { 0x1F21, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F91, result.begin()); + EXPECT_EQ(result, expected) << 0x1F91 << " 0x1F91"; + } + { + std::array const expected = { 0x1F22, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F92, result.begin()); + EXPECT_EQ(result, expected) << 0x1F92 << " 0x1F92"; + } + { + std::array const expected = { 0x1F23, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F93, result.begin()); + EXPECT_EQ(result, expected) << 0x1F93 << " 0x1F93"; + } + { + std::array const expected = { 0x1F24, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F94, result.begin()); + EXPECT_EQ(result, expected) << 0x1F94 << " 0x1F94"; + } + { + std::array const expected = { 0x1F25, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F95, result.begin()); + EXPECT_EQ(result, expected) << 0x1F95 << " 0x1F95"; + } + { + std::array const expected = { 0x1F26, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F96, result.begin()); + EXPECT_EQ(result, expected) << 0x1F96 << " 0x1F96"; + } + { + std::array const expected = { 0x1F27, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F97, result.begin()); + EXPECT_EQ(result, expected) << 0x1F97 << " 0x1F97"; + } + { + std::array const expected = { 0x1F20, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F98, result.begin()); + EXPECT_EQ(result, expected) << 0x1F98 << " 0x1F98"; + } + { + std::array const expected = { 0x1F21, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F99, result.begin()); + EXPECT_EQ(result, expected) << 0x1F99 << " 0x1F99"; + } + { + std::array const expected = { 0x1F22, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F9A, result.begin()); + EXPECT_EQ(result, expected) << 0x1F9A << " 0x1F9A"; + } + { + std::array const expected = { 0x1F23, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F9B, result.begin()); + EXPECT_EQ(result, expected) << 0x1F9B << " 0x1F9B"; + } + { + std::array const expected = { 0x1F24, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F9C, result.begin()); + EXPECT_EQ(result, expected) << 0x1F9C << " 0x1F9C"; + } + { + std::array const expected = { 0x1F25, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F9D, result.begin()); + EXPECT_EQ(result, expected) << 0x1F9D << " 0x1F9D"; + } +} + +TEST(case_folding, test_16) { + { + std::array const expected = { 0x1F26, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F9E, result.begin()); + EXPECT_EQ(result, expected) << 0x1F9E << " 0x1F9E"; + } + { + std::array const expected = { 0x1F27, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1F9F, result.begin()); + EXPECT_EQ(result, expected) << 0x1F9F << " 0x1F9F"; + } + { + std::array const expected = { 0x1F60, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FA0, result.begin()); + EXPECT_EQ(result, expected) << 0x1FA0 << " 0x1FA0"; + } + { + std::array const expected = { 0x1F61, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FA1, result.begin()); + EXPECT_EQ(result, expected) << 0x1FA1 << " 0x1FA1"; + } + { + std::array const expected = { 0x1F62, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FA2, result.begin()); + EXPECT_EQ(result, expected) << 0x1FA2 << " 0x1FA2"; + } + { + std::array const expected = { 0x1F63, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FA3, result.begin()); + EXPECT_EQ(result, expected) << 0x1FA3 << " 0x1FA3"; + } + { + std::array const expected = { 0x1F64, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FA4, result.begin()); + EXPECT_EQ(result, expected) << 0x1FA4 << " 0x1FA4"; + } + { + std::array const expected = { 0x1F65, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FA5, result.begin()); + EXPECT_EQ(result, expected) << 0x1FA5 << " 0x1FA5"; + } + { + std::array const expected = { 0x1F66, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FA6, result.begin()); + EXPECT_EQ(result, expected) << 0x1FA6 << " 0x1FA6"; + } + { + std::array const expected = { 0x1F67, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FA7, result.begin()); + EXPECT_EQ(result, expected) << 0x1FA7 << " 0x1FA7"; + } + { + std::array const expected = { 0x1F60, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FA8, result.begin()); + EXPECT_EQ(result, expected) << 0x1FA8 << " 0x1FA8"; + } + { + std::array const expected = { 0x1F61, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FA9, result.begin()); + EXPECT_EQ(result, expected) << 0x1FA9 << " 0x1FA9"; + } + { + std::array const expected = { 0x1F62, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FAA, result.begin()); + EXPECT_EQ(result, expected) << 0x1FAA << " 0x1FAA"; + } + { + std::array const expected = { 0x1F63, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FAB, result.begin()); + EXPECT_EQ(result, expected) << 0x1FAB << " 0x1FAB"; + } + { + std::array const expected = { 0x1F64, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FAC, result.begin()); + EXPECT_EQ(result, expected) << 0x1FAC << " 0x1FAC"; + } + { + std::array const expected = { 0x1F65, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FAD, result.begin()); + EXPECT_EQ(result, expected) << 0x1FAD << " 0x1FAD"; + } + { + std::array const expected = { 0x1F66, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FAE, result.begin()); + EXPECT_EQ(result, expected) << 0x1FAE << " 0x1FAE"; + } + { + std::array const expected = { 0x1F67, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FAF, result.begin()); + EXPECT_EQ(result, expected) << 0x1FAF << " 0x1FAF"; + } + { + std::array const expected = { 0x1F70, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FB2, result.begin()); + EXPECT_EQ(result, expected) << 0x1FB2 << " 0x1FB2"; + } + { + std::array const expected = { 0x03B1, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FB3, result.begin()); + EXPECT_EQ(result, expected) << 0x1FB3 << " 0x1FB3"; + } + { + std::array const expected = { 0x03AC, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FB4, result.begin()); + EXPECT_EQ(result, expected) << 0x1FB4 << " 0x1FB4"; + } + { + std::array const expected = { 0x03B1, 0x0342, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FB6, result.begin()); + EXPECT_EQ(result, expected) << 0x1FB6 << " 0x1FB6"; + } + { + std::array const expected = { 0x03B1, 0x0342, 0x03B9, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FB7, result.begin()); + EXPECT_EQ(result, expected) << 0x1FB7 << " 0x1FB7"; + } + { + std::array const expected = { 0x1FB0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FB8, result.begin()); + EXPECT_EQ(result, expected) << 0x1FB8 << " 0x1FB8"; + } + { + std::array const expected = { 0x1FB1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FB9, result.begin()); + EXPECT_EQ(result, expected) << 0x1FB9 << " 0x1FB9"; + } + { + std::array const expected = { 0x1F70, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FBA, result.begin()); + EXPECT_EQ(result, expected) << 0x1FBA << " 0x1FBA"; + } + { + std::array const expected = { 0x1F71, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FBB, result.begin()); + EXPECT_EQ(result, expected) << 0x1FBB << " 0x1FBB"; + } + { + std::array const expected = { 0x03B1, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FBC, result.begin()); + EXPECT_EQ(result, expected) << 0x1FBC << " 0x1FBC"; + } + { + std::array const expected = { 0x03B9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FBE, result.begin()); + EXPECT_EQ(result, expected) << 0x1FBE << " 0x1FBE"; + } + { + std::array const expected = { 0x1F74, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FC2, result.begin()); + EXPECT_EQ(result, expected) << 0x1FC2 << " 0x1FC2"; + } + { + std::array const expected = { 0x03B7, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FC3, result.begin()); + EXPECT_EQ(result, expected) << 0x1FC3 << " 0x1FC3"; + } + { + std::array const expected = { 0x03AE, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FC4, result.begin()); + EXPECT_EQ(result, expected) << 0x1FC4 << " 0x1FC4"; + } + { + std::array const expected = { 0x03B7, 0x0342, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FC6, result.begin()); + EXPECT_EQ(result, expected) << 0x1FC6 << " 0x1FC6"; + } + { + std::array const expected = { 0x03B7, 0x0342, 0x03B9, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FC7, result.begin()); + EXPECT_EQ(result, expected) << 0x1FC7 << " 0x1FC7"; + } + { + std::array const expected = { 0x1F72, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FC8, result.begin()); + EXPECT_EQ(result, expected) << 0x1FC8 << " 0x1FC8"; + } + { + std::array const expected = { 0x1F73, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FC9, result.begin()); + EXPECT_EQ(result, expected) << 0x1FC9 << " 0x1FC9"; + } + { + std::array const expected = { 0x1F74, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FCA, result.begin()); + EXPECT_EQ(result, expected) << 0x1FCA << " 0x1FCA"; + } + { + std::array const expected = { 0x1F75, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FCB, result.begin()); + EXPECT_EQ(result, expected) << 0x1FCB << " 0x1FCB"; + } + { + std::array const expected = { 0x03B7, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FCC, result.begin()); + EXPECT_EQ(result, expected) << 0x1FCC << " 0x1FCC"; + } + { + std::array const expected = { 0x03B9, 0x0308, 0x0300, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FD2, result.begin()); + EXPECT_EQ(result, expected) << 0x1FD2 << " 0x1FD2"; + } + { + std::array const expected = { 0x03B9, 0x0308, 0x0301, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FD3, result.begin()); + EXPECT_EQ(result, expected) << 0x1FD3 << " 0x1FD3"; + } + { + std::array const expected = { 0x03B9, 0x0342, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FD6, result.begin()); + EXPECT_EQ(result, expected) << 0x1FD6 << " 0x1FD6"; + } + { + std::array const expected = { 0x03B9, 0x0308, 0x0342, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FD7, result.begin()); + EXPECT_EQ(result, expected) << 0x1FD7 << " 0x1FD7"; + } + { + std::array const expected = { 0x1FD0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FD8, result.begin()); + EXPECT_EQ(result, expected) << 0x1FD8 << " 0x1FD8"; + } + { + std::array const expected = { 0x1FD1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FD9, result.begin()); + EXPECT_EQ(result, expected) << 0x1FD9 << " 0x1FD9"; + } + { + std::array const expected = { 0x1F76, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FDA, result.begin()); + EXPECT_EQ(result, expected) << 0x1FDA << " 0x1FDA"; + } + { + std::array const expected = { 0x1F77, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FDB, result.begin()); + EXPECT_EQ(result, expected) << 0x1FDB << " 0x1FDB"; + } + { + std::array const expected = { 0x03C5, 0x0308, 0x0300, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FE2, result.begin()); + EXPECT_EQ(result, expected) << 0x1FE2 << " 0x1FE2"; + } + { + std::array const expected = { 0x03C5, 0x0308, 0x0301, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FE3, result.begin()); + EXPECT_EQ(result, expected) << 0x1FE3 << " 0x1FE3"; + } + { + std::array const expected = { 0x03C1, 0x0313, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FE4, result.begin()); + EXPECT_EQ(result, expected) << 0x1FE4 << " 0x1FE4"; + } +} + +TEST(case_folding, test_17) { + { + std::array const expected = { 0x03C5, 0x0342, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FE6, result.begin()); + EXPECT_EQ(result, expected) << 0x1FE6 << " 0x1FE6"; + } + { + std::array const expected = { 0x03C5, 0x0308, 0x0342, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FE7, result.begin()); + EXPECT_EQ(result, expected) << 0x1FE7 << " 0x1FE7"; + } + { + std::array const expected = { 0x1FE0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FE8, result.begin()); + EXPECT_EQ(result, expected) << 0x1FE8 << " 0x1FE8"; + } + { + std::array const expected = { 0x1FE1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FE9, result.begin()); + EXPECT_EQ(result, expected) << 0x1FE9 << " 0x1FE9"; + } + { + std::array const expected = { 0x1F7A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FEA, result.begin()); + EXPECT_EQ(result, expected) << 0x1FEA << " 0x1FEA"; + } + { + std::array const expected = { 0x1F7B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FEB, result.begin()); + EXPECT_EQ(result, expected) << 0x1FEB << " 0x1FEB"; + } + { + std::array const expected = { 0x1FE5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FEC, result.begin()); + EXPECT_EQ(result, expected) << 0x1FEC << " 0x1FEC"; + } + { + std::array const expected = { 0x1F7C, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FF2, result.begin()); + EXPECT_EQ(result, expected) << 0x1FF2 << " 0x1FF2"; + } + { + std::array const expected = { 0x03C9, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FF3, result.begin()); + EXPECT_EQ(result, expected) << 0x1FF3 << " 0x1FF3"; + } + { + std::array const expected = { 0x03CE, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FF4, result.begin()); + EXPECT_EQ(result, expected) << 0x1FF4 << " 0x1FF4"; + } + { + std::array const expected = { 0x03C9, 0x0342, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FF6, result.begin()); + EXPECT_EQ(result, expected) << 0x1FF6 << " 0x1FF6"; + } + { + std::array const expected = { 0x03C9, 0x0342, 0x03B9, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FF7, result.begin()); + EXPECT_EQ(result, expected) << 0x1FF7 << " 0x1FF7"; + } + { + std::array const expected = { 0x1F78, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FF8, result.begin()); + EXPECT_EQ(result, expected) << 0x1FF8 << " 0x1FF8"; + } + { + std::array const expected = { 0x1F79, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FF9, result.begin()); + EXPECT_EQ(result, expected) << 0x1FF9 << " 0x1FF9"; + } + { + std::array const expected = { 0x1F7C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FFA, result.begin()); + EXPECT_EQ(result, expected) << 0x1FFA << " 0x1FFA"; + } + { + std::array const expected = { 0x1F7D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FFB, result.begin()); + EXPECT_EQ(result, expected) << 0x1FFB << " 0x1FFB"; + } + { + std::array const expected = { 0x03C9, 0x03B9, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1FFC, result.begin()); + EXPECT_EQ(result, expected) << 0x1FFC << " 0x1FFC"; + } + { + std::array const expected = { 0x03C9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2126, result.begin()); + EXPECT_EQ(result, expected) << 0x2126 << " 0x2126"; + } + { + std::array const expected = { 0x006B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x212A, result.begin()); + EXPECT_EQ(result, expected) << 0x212A << " 0x212A"; + } + { + std::array const expected = { 0x00E5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x212B, result.begin()); + EXPECT_EQ(result, expected) << 0x212B << " 0x212B"; + } + { + std::array const expected = { 0x214E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2132, result.begin()); + EXPECT_EQ(result, expected) << 0x2132 << " 0x2132"; + } + { + std::array const expected = { 0x2170, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2160, result.begin()); + EXPECT_EQ(result, expected) << 0x2160 << " 0x2160"; + } + { + std::array const expected = { 0x2171, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2161, result.begin()); + EXPECT_EQ(result, expected) << 0x2161 << " 0x2161"; + } + { + std::array const expected = { 0x2172, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2162, result.begin()); + EXPECT_EQ(result, expected) << 0x2162 << " 0x2162"; + } + { + std::array const expected = { 0x2173, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2163, result.begin()); + EXPECT_EQ(result, expected) << 0x2163 << " 0x2163"; + } + { + std::array const expected = { 0x2174, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2164, result.begin()); + EXPECT_EQ(result, expected) << 0x2164 << " 0x2164"; + } + { + std::array const expected = { 0x2175, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2165, result.begin()); + EXPECT_EQ(result, expected) << 0x2165 << " 0x2165"; + } + { + std::array const expected = { 0x2176, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2166, result.begin()); + EXPECT_EQ(result, expected) << 0x2166 << " 0x2166"; + } + { + std::array const expected = { 0x2177, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2167, result.begin()); + EXPECT_EQ(result, expected) << 0x2167 << " 0x2167"; + } + { + std::array const expected = { 0x2178, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2168, result.begin()); + EXPECT_EQ(result, expected) << 0x2168 << " 0x2168"; + } + { + std::array const expected = { 0x2179, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2169, result.begin()); + EXPECT_EQ(result, expected) << 0x2169 << " 0x2169"; + } + { + std::array const expected = { 0x217A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x216A, result.begin()); + EXPECT_EQ(result, expected) << 0x216A << " 0x216A"; + } + { + std::array const expected = { 0x217B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x216B, result.begin()); + EXPECT_EQ(result, expected) << 0x216B << " 0x216B"; + } + { + std::array const expected = { 0x217C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x216C, result.begin()); + EXPECT_EQ(result, expected) << 0x216C << " 0x216C"; + } + { + std::array const expected = { 0x217D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x216D, result.begin()); + EXPECT_EQ(result, expected) << 0x216D << " 0x216D"; + } + { + std::array const expected = { 0x217E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x216E, result.begin()); + EXPECT_EQ(result, expected) << 0x216E << " 0x216E"; + } + { + std::array const expected = { 0x217F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x216F, result.begin()); + EXPECT_EQ(result, expected) << 0x216F << " 0x216F"; + } + { + std::array const expected = { 0x2184, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2183, result.begin()); + EXPECT_EQ(result, expected) << 0x2183 << " 0x2183"; + } + { + std::array const expected = { 0x24D0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24B6, result.begin()); + EXPECT_EQ(result, expected) << 0x24B6 << " 0x24B6"; + } + { + std::array const expected = { 0x24D1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24B7, result.begin()); + EXPECT_EQ(result, expected) << 0x24B7 << " 0x24B7"; + } + { + std::array const expected = { 0x24D2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24B8, result.begin()); + EXPECT_EQ(result, expected) << 0x24B8 << " 0x24B8"; + } + { + std::array const expected = { 0x24D3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24B9, result.begin()); + EXPECT_EQ(result, expected) << 0x24B9 << " 0x24B9"; + } + { + std::array const expected = { 0x24D4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24BA, result.begin()); + EXPECT_EQ(result, expected) << 0x24BA << " 0x24BA"; + } + { + std::array const expected = { 0x24D5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24BB, result.begin()); + EXPECT_EQ(result, expected) << 0x24BB << " 0x24BB"; + } + { + std::array const expected = { 0x24D6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24BC, result.begin()); + EXPECT_EQ(result, expected) << 0x24BC << " 0x24BC"; + } + { + std::array const expected = { 0x24D7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24BD, result.begin()); + EXPECT_EQ(result, expected) << 0x24BD << " 0x24BD"; + } + { + std::array const expected = { 0x24D8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24BE, result.begin()); + EXPECT_EQ(result, expected) << 0x24BE << " 0x24BE"; + } + { + std::array const expected = { 0x24D9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24BF, result.begin()); + EXPECT_EQ(result, expected) << 0x24BF << " 0x24BF"; + } + { + std::array const expected = { 0x24DA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24C0, result.begin()); + EXPECT_EQ(result, expected) << 0x24C0 << " 0x24C0"; + } + { + std::array const expected = { 0x24DB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24C1, result.begin()); + EXPECT_EQ(result, expected) << 0x24C1 << " 0x24C1"; + } +} + +TEST(case_folding, test_18) { + { + std::array const expected = { 0x24DC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24C2, result.begin()); + EXPECT_EQ(result, expected) << 0x24C2 << " 0x24C2"; + } + { + std::array const expected = { 0x24DD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24C3, result.begin()); + EXPECT_EQ(result, expected) << 0x24C3 << " 0x24C3"; + } + { + std::array const expected = { 0x24DE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24C4, result.begin()); + EXPECT_EQ(result, expected) << 0x24C4 << " 0x24C4"; + } + { + std::array const expected = { 0x24DF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24C5, result.begin()); + EXPECT_EQ(result, expected) << 0x24C5 << " 0x24C5"; + } + { + std::array const expected = { 0x24E0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24C6, result.begin()); + EXPECT_EQ(result, expected) << 0x24C6 << " 0x24C6"; + } + { + std::array const expected = { 0x24E1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24C7, result.begin()); + EXPECT_EQ(result, expected) << 0x24C7 << " 0x24C7"; + } + { + std::array const expected = { 0x24E2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24C8, result.begin()); + EXPECT_EQ(result, expected) << 0x24C8 << " 0x24C8"; + } + { + std::array const expected = { 0x24E3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24C9, result.begin()); + EXPECT_EQ(result, expected) << 0x24C9 << " 0x24C9"; + } + { + std::array const expected = { 0x24E4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24CA, result.begin()); + EXPECT_EQ(result, expected) << 0x24CA << " 0x24CA"; + } + { + std::array const expected = { 0x24E5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24CB, result.begin()); + EXPECT_EQ(result, expected) << 0x24CB << " 0x24CB"; + } + { + std::array const expected = { 0x24E6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24CC, result.begin()); + EXPECT_EQ(result, expected) << 0x24CC << " 0x24CC"; + } + { + std::array const expected = { 0x24E7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24CD, result.begin()); + EXPECT_EQ(result, expected) << 0x24CD << " 0x24CD"; + } + { + std::array const expected = { 0x24E8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24CE, result.begin()); + EXPECT_EQ(result, expected) << 0x24CE << " 0x24CE"; + } + { + std::array const expected = { 0x24E9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x24CF, result.begin()); + EXPECT_EQ(result, expected) << 0x24CF << " 0x24CF"; + } + { + std::array const expected = { 0x2C30, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C00, result.begin()); + EXPECT_EQ(result, expected) << 0x2C00 << " 0x2C00"; + } + { + std::array const expected = { 0x2C31, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C01, result.begin()); + EXPECT_EQ(result, expected) << 0x2C01 << " 0x2C01"; + } + { + std::array const expected = { 0x2C32, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C02, result.begin()); + EXPECT_EQ(result, expected) << 0x2C02 << " 0x2C02"; + } + { + std::array const expected = { 0x2C33, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C03, result.begin()); + EXPECT_EQ(result, expected) << 0x2C03 << " 0x2C03"; + } + { + std::array const expected = { 0x2C34, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C04, result.begin()); + EXPECT_EQ(result, expected) << 0x2C04 << " 0x2C04"; + } + { + std::array const expected = { 0x2C35, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C05, result.begin()); + EXPECT_EQ(result, expected) << 0x2C05 << " 0x2C05"; + } + { + std::array const expected = { 0x2C36, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C06, result.begin()); + EXPECT_EQ(result, expected) << 0x2C06 << " 0x2C06"; + } + { + std::array const expected = { 0x2C37, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C07, result.begin()); + EXPECT_EQ(result, expected) << 0x2C07 << " 0x2C07"; + } + { + std::array const expected = { 0x2C38, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C08, result.begin()); + EXPECT_EQ(result, expected) << 0x2C08 << " 0x2C08"; + } + { + std::array const expected = { 0x2C39, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C09, result.begin()); + EXPECT_EQ(result, expected) << 0x2C09 << " 0x2C09"; + } + { + std::array const expected = { 0x2C3A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C0A, result.begin()); + EXPECT_EQ(result, expected) << 0x2C0A << " 0x2C0A"; + } + { + std::array const expected = { 0x2C3B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C0B, result.begin()); + EXPECT_EQ(result, expected) << 0x2C0B << " 0x2C0B"; + } + { + std::array const expected = { 0x2C3C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C0C, result.begin()); + EXPECT_EQ(result, expected) << 0x2C0C << " 0x2C0C"; + } + { + std::array const expected = { 0x2C3D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C0D, result.begin()); + EXPECT_EQ(result, expected) << 0x2C0D << " 0x2C0D"; + } + { + std::array const expected = { 0x2C3E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C0E, result.begin()); + EXPECT_EQ(result, expected) << 0x2C0E << " 0x2C0E"; + } + { + std::array const expected = { 0x2C3F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C0F, result.begin()); + EXPECT_EQ(result, expected) << 0x2C0F << " 0x2C0F"; + } + { + std::array const expected = { 0x2C40, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C10, result.begin()); + EXPECT_EQ(result, expected) << 0x2C10 << " 0x2C10"; + } + { + std::array const expected = { 0x2C41, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C11, result.begin()); + EXPECT_EQ(result, expected) << 0x2C11 << " 0x2C11"; + } + { + std::array const expected = { 0x2C42, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C12, result.begin()); + EXPECT_EQ(result, expected) << 0x2C12 << " 0x2C12"; + } + { + std::array const expected = { 0x2C43, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C13, result.begin()); + EXPECT_EQ(result, expected) << 0x2C13 << " 0x2C13"; + } + { + std::array const expected = { 0x2C44, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C14, result.begin()); + EXPECT_EQ(result, expected) << 0x2C14 << " 0x2C14"; + } + { + std::array const expected = { 0x2C45, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C15, result.begin()); + EXPECT_EQ(result, expected) << 0x2C15 << " 0x2C15"; + } + { + std::array const expected = { 0x2C46, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C16, result.begin()); + EXPECT_EQ(result, expected) << 0x2C16 << " 0x2C16"; + } + { + std::array const expected = { 0x2C47, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C17, result.begin()); + EXPECT_EQ(result, expected) << 0x2C17 << " 0x2C17"; + } + { + std::array const expected = { 0x2C48, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C18, result.begin()); + EXPECT_EQ(result, expected) << 0x2C18 << " 0x2C18"; + } + { + std::array const expected = { 0x2C49, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C19, result.begin()); + EXPECT_EQ(result, expected) << 0x2C19 << " 0x2C19"; + } + { + std::array const expected = { 0x2C4A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C1A, result.begin()); + EXPECT_EQ(result, expected) << 0x2C1A << " 0x2C1A"; + } + { + std::array const expected = { 0x2C4B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C1B, result.begin()); + EXPECT_EQ(result, expected) << 0x2C1B << " 0x2C1B"; + } + { + std::array const expected = { 0x2C4C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C1C, result.begin()); + EXPECT_EQ(result, expected) << 0x2C1C << " 0x2C1C"; + } + { + std::array const expected = { 0x2C4D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C1D, result.begin()); + EXPECT_EQ(result, expected) << 0x2C1D << " 0x2C1D"; + } + { + std::array const expected = { 0x2C4E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C1E, result.begin()); + EXPECT_EQ(result, expected) << 0x2C1E << " 0x2C1E"; + } + { + std::array const expected = { 0x2C4F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C1F, result.begin()); + EXPECT_EQ(result, expected) << 0x2C1F << " 0x2C1F"; + } + { + std::array const expected = { 0x2C50, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C20, result.begin()); + EXPECT_EQ(result, expected) << 0x2C20 << " 0x2C20"; + } + { + std::array const expected = { 0x2C51, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C21, result.begin()); + EXPECT_EQ(result, expected) << 0x2C21 << " 0x2C21"; + } + { + std::array const expected = { 0x2C52, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C22, result.begin()); + EXPECT_EQ(result, expected) << 0x2C22 << " 0x2C22"; + } + { + std::array const expected = { 0x2C53, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C23, result.begin()); + EXPECT_EQ(result, expected) << 0x2C23 << " 0x2C23"; + } +} + +TEST(case_folding, test_19) { + { + std::array const expected = { 0x2C54, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C24, result.begin()); + EXPECT_EQ(result, expected) << 0x2C24 << " 0x2C24"; + } + { + std::array const expected = { 0x2C55, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C25, result.begin()); + EXPECT_EQ(result, expected) << 0x2C25 << " 0x2C25"; + } + { + std::array const expected = { 0x2C56, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C26, result.begin()); + EXPECT_EQ(result, expected) << 0x2C26 << " 0x2C26"; + } + { + std::array const expected = { 0x2C57, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C27, result.begin()); + EXPECT_EQ(result, expected) << 0x2C27 << " 0x2C27"; + } + { + std::array const expected = { 0x2C58, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C28, result.begin()); + EXPECT_EQ(result, expected) << 0x2C28 << " 0x2C28"; + } + { + std::array const expected = { 0x2C59, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C29, result.begin()); + EXPECT_EQ(result, expected) << 0x2C29 << " 0x2C29"; + } + { + std::array const expected = { 0x2C5A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C2A, result.begin()); + EXPECT_EQ(result, expected) << 0x2C2A << " 0x2C2A"; + } + { + std::array const expected = { 0x2C5B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C2B, result.begin()); + EXPECT_EQ(result, expected) << 0x2C2B << " 0x2C2B"; + } + { + std::array const expected = { 0x2C5C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C2C, result.begin()); + EXPECT_EQ(result, expected) << 0x2C2C << " 0x2C2C"; + } + { + std::array const expected = { 0x2C5D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C2D, result.begin()); + EXPECT_EQ(result, expected) << 0x2C2D << " 0x2C2D"; + } + { + std::array const expected = { 0x2C5E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C2E, result.begin()); + EXPECT_EQ(result, expected) << 0x2C2E << " 0x2C2E"; + } + { + std::array const expected = { 0x2C5F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C2F, result.begin()); + EXPECT_EQ(result, expected) << 0x2C2F << " 0x2C2F"; + } + { + std::array const expected = { 0x2C61, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C60, result.begin()); + EXPECT_EQ(result, expected) << 0x2C60 << " 0x2C60"; + } + { + std::array const expected = { 0x026B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C62, result.begin()); + EXPECT_EQ(result, expected) << 0x2C62 << " 0x2C62"; + } + { + std::array const expected = { 0x1D7D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C63, result.begin()); + EXPECT_EQ(result, expected) << 0x2C63 << " 0x2C63"; + } + { + std::array const expected = { 0x027D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C64, result.begin()); + EXPECT_EQ(result, expected) << 0x2C64 << " 0x2C64"; + } + { + std::array const expected = { 0x2C68, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C67, result.begin()); + EXPECT_EQ(result, expected) << 0x2C67 << " 0x2C67"; + } + { + std::array const expected = { 0x2C6A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C69, result.begin()); + EXPECT_EQ(result, expected) << 0x2C69 << " 0x2C69"; + } + { + std::array const expected = { 0x2C6C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C6B, result.begin()); + EXPECT_EQ(result, expected) << 0x2C6B << " 0x2C6B"; + } + { + std::array const expected = { 0x0251, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C6D, result.begin()); + EXPECT_EQ(result, expected) << 0x2C6D << " 0x2C6D"; + } + { + std::array const expected = { 0x0271, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C6E, result.begin()); + EXPECT_EQ(result, expected) << 0x2C6E << " 0x2C6E"; + } + { + std::array const expected = { 0x0250, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C6F, result.begin()); + EXPECT_EQ(result, expected) << 0x2C6F << " 0x2C6F"; + } + { + std::array const expected = { 0x0252, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C70, result.begin()); + EXPECT_EQ(result, expected) << 0x2C70 << " 0x2C70"; + } + { + std::array const expected = { 0x2C73, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C72, result.begin()); + EXPECT_EQ(result, expected) << 0x2C72 << " 0x2C72"; + } + { + std::array const expected = { 0x2C76, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C75, result.begin()); + EXPECT_EQ(result, expected) << 0x2C75 << " 0x2C75"; + } + { + std::array const expected = { 0x023F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C7E, result.begin()); + EXPECT_EQ(result, expected) << 0x2C7E << " 0x2C7E"; + } + { + std::array const expected = { 0x0240, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C7F, result.begin()); + EXPECT_EQ(result, expected) << 0x2C7F << " 0x2C7F"; + } + { + std::array const expected = { 0x2C81, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C80, result.begin()); + EXPECT_EQ(result, expected) << 0x2C80 << " 0x2C80"; + } + { + std::array const expected = { 0x2C83, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C82, result.begin()); + EXPECT_EQ(result, expected) << 0x2C82 << " 0x2C82"; + } + { + std::array const expected = { 0x2C85, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C84, result.begin()); + EXPECT_EQ(result, expected) << 0x2C84 << " 0x2C84"; + } + { + std::array const expected = { 0x2C87, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C86, result.begin()); + EXPECT_EQ(result, expected) << 0x2C86 << " 0x2C86"; + } + { + std::array const expected = { 0x2C89, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C88, result.begin()); + EXPECT_EQ(result, expected) << 0x2C88 << " 0x2C88"; + } + { + std::array const expected = { 0x2C8B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C8A, result.begin()); + EXPECT_EQ(result, expected) << 0x2C8A << " 0x2C8A"; + } + { + std::array const expected = { 0x2C8D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C8C, result.begin()); + EXPECT_EQ(result, expected) << 0x2C8C << " 0x2C8C"; + } + { + std::array const expected = { 0x2C8F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C8E, result.begin()); + EXPECT_EQ(result, expected) << 0x2C8E << " 0x2C8E"; + } + { + std::array const expected = { 0x2C91, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C90, result.begin()); + EXPECT_EQ(result, expected) << 0x2C90 << " 0x2C90"; + } + { + std::array const expected = { 0x2C93, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C92, result.begin()); + EXPECT_EQ(result, expected) << 0x2C92 << " 0x2C92"; + } + { + std::array const expected = { 0x2C95, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C94, result.begin()); + EXPECT_EQ(result, expected) << 0x2C94 << " 0x2C94"; + } + { + std::array const expected = { 0x2C97, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C96, result.begin()); + EXPECT_EQ(result, expected) << 0x2C96 << " 0x2C96"; + } + { + std::array const expected = { 0x2C99, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C98, result.begin()); + EXPECT_EQ(result, expected) << 0x2C98 << " 0x2C98"; + } + { + std::array const expected = { 0x2C9B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C9A, result.begin()); + EXPECT_EQ(result, expected) << 0x2C9A << " 0x2C9A"; + } + { + std::array const expected = { 0x2C9D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C9C, result.begin()); + EXPECT_EQ(result, expected) << 0x2C9C << " 0x2C9C"; + } + { + std::array const expected = { 0x2C9F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2C9E, result.begin()); + EXPECT_EQ(result, expected) << 0x2C9E << " 0x2C9E"; + } + { + std::array const expected = { 0x2CA1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CA0, result.begin()); + EXPECT_EQ(result, expected) << 0x2CA0 << " 0x2CA0"; + } + { + std::array const expected = { 0x2CA3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CA2, result.begin()); + EXPECT_EQ(result, expected) << 0x2CA2 << " 0x2CA2"; + } + { + std::array const expected = { 0x2CA5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CA4, result.begin()); + EXPECT_EQ(result, expected) << 0x2CA4 << " 0x2CA4"; + } + { + std::array const expected = { 0x2CA7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CA6, result.begin()); + EXPECT_EQ(result, expected) << 0x2CA6 << " 0x2CA6"; + } + { + std::array const expected = { 0x2CA9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CA8, result.begin()); + EXPECT_EQ(result, expected) << 0x2CA8 << " 0x2CA8"; + } + { + std::array const expected = { 0x2CAB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CAA, result.begin()); + EXPECT_EQ(result, expected) << 0x2CAA << " 0x2CAA"; + } + { + std::array const expected = { 0x2CAD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CAC, result.begin()); + EXPECT_EQ(result, expected) << 0x2CAC << " 0x2CAC"; + } +} + +TEST(case_folding, test_20) { + { + std::array const expected = { 0x2CAF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CAE, result.begin()); + EXPECT_EQ(result, expected) << 0x2CAE << " 0x2CAE"; + } + { + std::array const expected = { 0x2CB1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CB0, result.begin()); + EXPECT_EQ(result, expected) << 0x2CB0 << " 0x2CB0"; + } + { + std::array const expected = { 0x2CB3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CB2, result.begin()); + EXPECT_EQ(result, expected) << 0x2CB2 << " 0x2CB2"; + } + { + std::array const expected = { 0x2CB5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CB4, result.begin()); + EXPECT_EQ(result, expected) << 0x2CB4 << " 0x2CB4"; + } + { + std::array const expected = { 0x2CB7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CB6, result.begin()); + EXPECT_EQ(result, expected) << 0x2CB6 << " 0x2CB6"; + } + { + std::array const expected = { 0x2CB9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CB8, result.begin()); + EXPECT_EQ(result, expected) << 0x2CB8 << " 0x2CB8"; + } + { + std::array const expected = { 0x2CBB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CBA, result.begin()); + EXPECT_EQ(result, expected) << 0x2CBA << " 0x2CBA"; + } + { + std::array const expected = { 0x2CBD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CBC, result.begin()); + EXPECT_EQ(result, expected) << 0x2CBC << " 0x2CBC"; + } + { + std::array const expected = { 0x2CBF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CBE, result.begin()); + EXPECT_EQ(result, expected) << 0x2CBE << " 0x2CBE"; + } + { + std::array const expected = { 0x2CC1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CC0, result.begin()); + EXPECT_EQ(result, expected) << 0x2CC0 << " 0x2CC0"; + } + { + std::array const expected = { 0x2CC3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CC2, result.begin()); + EXPECT_EQ(result, expected) << 0x2CC2 << " 0x2CC2"; + } + { + std::array const expected = { 0x2CC5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CC4, result.begin()); + EXPECT_EQ(result, expected) << 0x2CC4 << " 0x2CC4"; + } + { + std::array const expected = { 0x2CC7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CC6, result.begin()); + EXPECT_EQ(result, expected) << 0x2CC6 << " 0x2CC6"; + } + { + std::array const expected = { 0x2CC9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CC8, result.begin()); + EXPECT_EQ(result, expected) << 0x2CC8 << " 0x2CC8"; + } + { + std::array const expected = { 0x2CCB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CCA, result.begin()); + EXPECT_EQ(result, expected) << 0x2CCA << " 0x2CCA"; + } + { + std::array const expected = { 0x2CCD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CCC, result.begin()); + EXPECT_EQ(result, expected) << 0x2CCC << " 0x2CCC"; + } + { + std::array const expected = { 0x2CCF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CCE, result.begin()); + EXPECT_EQ(result, expected) << 0x2CCE << " 0x2CCE"; + } + { + std::array const expected = { 0x2CD1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CD0, result.begin()); + EXPECT_EQ(result, expected) << 0x2CD0 << " 0x2CD0"; + } + { + std::array const expected = { 0x2CD3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CD2, result.begin()); + EXPECT_EQ(result, expected) << 0x2CD2 << " 0x2CD2"; + } + { + std::array const expected = { 0x2CD5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CD4, result.begin()); + EXPECT_EQ(result, expected) << 0x2CD4 << " 0x2CD4"; + } + { + std::array const expected = { 0x2CD7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CD6, result.begin()); + EXPECT_EQ(result, expected) << 0x2CD6 << " 0x2CD6"; + } + { + std::array const expected = { 0x2CD9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CD8, result.begin()); + EXPECT_EQ(result, expected) << 0x2CD8 << " 0x2CD8"; + } + { + std::array const expected = { 0x2CDB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CDA, result.begin()); + EXPECT_EQ(result, expected) << 0x2CDA << " 0x2CDA"; + } + { + std::array const expected = { 0x2CDD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CDC, result.begin()); + EXPECT_EQ(result, expected) << 0x2CDC << " 0x2CDC"; + } + { + std::array const expected = { 0x2CDF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CDE, result.begin()); + EXPECT_EQ(result, expected) << 0x2CDE << " 0x2CDE"; + } + { + std::array const expected = { 0x2CE1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CE0, result.begin()); + EXPECT_EQ(result, expected) << 0x2CE0 << " 0x2CE0"; + } + { + std::array const expected = { 0x2CE3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CE2, result.begin()); + EXPECT_EQ(result, expected) << 0x2CE2 << " 0x2CE2"; + } + { + std::array const expected = { 0x2CEC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CEB, result.begin()); + EXPECT_EQ(result, expected) << 0x2CEB << " 0x2CEB"; + } + { + std::array const expected = { 0x2CEE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CED, result.begin()); + EXPECT_EQ(result, expected) << 0x2CED << " 0x2CED"; + } + { + std::array const expected = { 0x2CF3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x2CF2, result.begin()); + EXPECT_EQ(result, expected) << 0x2CF2 << " 0x2CF2"; + } + { + std::array const expected = { 0xA641, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA640, result.begin()); + EXPECT_EQ(result, expected) << 0xA640 << " 0xA640"; + } + { + std::array const expected = { 0xA643, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA642, result.begin()); + EXPECT_EQ(result, expected) << 0xA642 << " 0xA642"; + } + { + std::array const expected = { 0xA645, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA644, result.begin()); + EXPECT_EQ(result, expected) << 0xA644 << " 0xA644"; + } + { + std::array const expected = { 0xA647, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA646, result.begin()); + EXPECT_EQ(result, expected) << 0xA646 << " 0xA646"; + } + { + std::array const expected = { 0xA649, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA648, result.begin()); + EXPECT_EQ(result, expected) << 0xA648 << " 0xA648"; + } + { + std::array const expected = { 0xA64B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA64A, result.begin()); + EXPECT_EQ(result, expected) << 0xA64A << " 0xA64A"; + } + { + std::array const expected = { 0xA64D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA64C, result.begin()); + EXPECT_EQ(result, expected) << 0xA64C << " 0xA64C"; + } + { + std::array const expected = { 0xA64F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA64E, result.begin()); + EXPECT_EQ(result, expected) << 0xA64E << " 0xA64E"; + } + { + std::array const expected = { 0xA651, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA650, result.begin()); + EXPECT_EQ(result, expected) << 0xA650 << " 0xA650"; + } + { + std::array const expected = { 0xA653, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA652, result.begin()); + EXPECT_EQ(result, expected) << 0xA652 << " 0xA652"; + } + { + std::array const expected = { 0xA655, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA654, result.begin()); + EXPECT_EQ(result, expected) << 0xA654 << " 0xA654"; + } + { + std::array const expected = { 0xA657, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA656, result.begin()); + EXPECT_EQ(result, expected) << 0xA656 << " 0xA656"; + } + { + std::array const expected = { 0xA659, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA658, result.begin()); + EXPECT_EQ(result, expected) << 0xA658 << " 0xA658"; + } + { + std::array const expected = { 0xA65B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA65A, result.begin()); + EXPECT_EQ(result, expected) << 0xA65A << " 0xA65A"; + } + { + std::array const expected = { 0xA65D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA65C, result.begin()); + EXPECT_EQ(result, expected) << 0xA65C << " 0xA65C"; + } + { + std::array const expected = { 0xA65F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA65E, result.begin()); + EXPECT_EQ(result, expected) << 0xA65E << " 0xA65E"; + } + { + std::array const expected = { 0xA661, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA660, result.begin()); + EXPECT_EQ(result, expected) << 0xA660 << " 0xA660"; + } + { + std::array const expected = { 0xA663, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA662, result.begin()); + EXPECT_EQ(result, expected) << 0xA662 << " 0xA662"; + } + { + std::array const expected = { 0xA665, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA664, result.begin()); + EXPECT_EQ(result, expected) << 0xA664 << " 0xA664"; + } + { + std::array const expected = { 0xA667, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA666, result.begin()); + EXPECT_EQ(result, expected) << 0xA666 << " 0xA666"; + } +} + +TEST(case_folding, test_21) { + { + std::array const expected = { 0xA669, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA668, result.begin()); + EXPECT_EQ(result, expected) << 0xA668 << " 0xA668"; + } + { + std::array const expected = { 0xA66B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA66A, result.begin()); + EXPECT_EQ(result, expected) << 0xA66A << " 0xA66A"; + } + { + std::array const expected = { 0xA66D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA66C, result.begin()); + EXPECT_EQ(result, expected) << 0xA66C << " 0xA66C"; + } + { + std::array const expected = { 0xA681, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA680, result.begin()); + EXPECT_EQ(result, expected) << 0xA680 << " 0xA680"; + } + { + std::array const expected = { 0xA683, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA682, result.begin()); + EXPECT_EQ(result, expected) << 0xA682 << " 0xA682"; + } + { + std::array const expected = { 0xA685, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA684, result.begin()); + EXPECT_EQ(result, expected) << 0xA684 << " 0xA684"; + } + { + std::array const expected = { 0xA687, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA686, result.begin()); + EXPECT_EQ(result, expected) << 0xA686 << " 0xA686"; + } + { + std::array const expected = { 0xA689, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA688, result.begin()); + EXPECT_EQ(result, expected) << 0xA688 << " 0xA688"; + } + { + std::array const expected = { 0xA68B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA68A, result.begin()); + EXPECT_EQ(result, expected) << 0xA68A << " 0xA68A"; + } + { + std::array const expected = { 0xA68D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA68C, result.begin()); + EXPECT_EQ(result, expected) << 0xA68C << " 0xA68C"; + } + { + std::array const expected = { 0xA68F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA68E, result.begin()); + EXPECT_EQ(result, expected) << 0xA68E << " 0xA68E"; + } + { + std::array const expected = { 0xA691, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA690, result.begin()); + EXPECT_EQ(result, expected) << 0xA690 << " 0xA690"; + } + { + std::array const expected = { 0xA693, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA692, result.begin()); + EXPECT_EQ(result, expected) << 0xA692 << " 0xA692"; + } + { + std::array const expected = { 0xA695, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA694, result.begin()); + EXPECT_EQ(result, expected) << 0xA694 << " 0xA694"; + } + { + std::array const expected = { 0xA697, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA696, result.begin()); + EXPECT_EQ(result, expected) << 0xA696 << " 0xA696"; + } + { + std::array const expected = { 0xA699, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA698, result.begin()); + EXPECT_EQ(result, expected) << 0xA698 << " 0xA698"; + } + { + std::array const expected = { 0xA69B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA69A, result.begin()); + EXPECT_EQ(result, expected) << 0xA69A << " 0xA69A"; + } + { + std::array const expected = { 0xA723, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA722, result.begin()); + EXPECT_EQ(result, expected) << 0xA722 << " 0xA722"; + } + { + std::array const expected = { 0xA725, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA724, result.begin()); + EXPECT_EQ(result, expected) << 0xA724 << " 0xA724"; + } + { + std::array const expected = { 0xA727, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA726, result.begin()); + EXPECT_EQ(result, expected) << 0xA726 << " 0xA726"; + } + { + std::array const expected = { 0xA729, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA728, result.begin()); + EXPECT_EQ(result, expected) << 0xA728 << " 0xA728"; + } + { + std::array const expected = { 0xA72B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA72A, result.begin()); + EXPECT_EQ(result, expected) << 0xA72A << " 0xA72A"; + } + { + std::array const expected = { 0xA72D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA72C, result.begin()); + EXPECT_EQ(result, expected) << 0xA72C << " 0xA72C"; + } + { + std::array const expected = { 0xA72F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA72E, result.begin()); + EXPECT_EQ(result, expected) << 0xA72E << " 0xA72E"; + } + { + std::array const expected = { 0xA733, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA732, result.begin()); + EXPECT_EQ(result, expected) << 0xA732 << " 0xA732"; + } + { + std::array const expected = { 0xA735, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA734, result.begin()); + EXPECT_EQ(result, expected) << 0xA734 << " 0xA734"; + } + { + std::array const expected = { 0xA737, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA736, result.begin()); + EXPECT_EQ(result, expected) << 0xA736 << " 0xA736"; + } + { + std::array const expected = { 0xA739, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA738, result.begin()); + EXPECT_EQ(result, expected) << 0xA738 << " 0xA738"; + } + { + std::array const expected = { 0xA73B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA73A, result.begin()); + EXPECT_EQ(result, expected) << 0xA73A << " 0xA73A"; + } + { + std::array const expected = { 0xA73D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA73C, result.begin()); + EXPECT_EQ(result, expected) << 0xA73C << " 0xA73C"; + } + { + std::array const expected = { 0xA73F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA73E, result.begin()); + EXPECT_EQ(result, expected) << 0xA73E << " 0xA73E"; + } + { + std::array const expected = { 0xA741, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA740, result.begin()); + EXPECT_EQ(result, expected) << 0xA740 << " 0xA740"; + } + { + std::array const expected = { 0xA743, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA742, result.begin()); + EXPECT_EQ(result, expected) << 0xA742 << " 0xA742"; + } + { + std::array const expected = { 0xA745, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA744, result.begin()); + EXPECT_EQ(result, expected) << 0xA744 << " 0xA744"; + } + { + std::array const expected = { 0xA747, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA746, result.begin()); + EXPECT_EQ(result, expected) << 0xA746 << " 0xA746"; + } + { + std::array const expected = { 0xA749, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA748, result.begin()); + EXPECT_EQ(result, expected) << 0xA748 << " 0xA748"; + } + { + std::array const expected = { 0xA74B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA74A, result.begin()); + EXPECT_EQ(result, expected) << 0xA74A << " 0xA74A"; + } + { + std::array const expected = { 0xA74D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA74C, result.begin()); + EXPECT_EQ(result, expected) << 0xA74C << " 0xA74C"; + } + { + std::array const expected = { 0xA74F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA74E, result.begin()); + EXPECT_EQ(result, expected) << 0xA74E << " 0xA74E"; + } + { + std::array const expected = { 0xA751, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA750, result.begin()); + EXPECT_EQ(result, expected) << 0xA750 << " 0xA750"; + } + { + std::array const expected = { 0xA753, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA752, result.begin()); + EXPECT_EQ(result, expected) << 0xA752 << " 0xA752"; + } + { + std::array const expected = { 0xA755, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA754, result.begin()); + EXPECT_EQ(result, expected) << 0xA754 << " 0xA754"; + } + { + std::array const expected = { 0xA757, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA756, result.begin()); + EXPECT_EQ(result, expected) << 0xA756 << " 0xA756"; + } + { + std::array const expected = { 0xA759, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA758, result.begin()); + EXPECT_EQ(result, expected) << 0xA758 << " 0xA758"; + } + { + std::array const expected = { 0xA75B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA75A, result.begin()); + EXPECT_EQ(result, expected) << 0xA75A << " 0xA75A"; + } + { + std::array const expected = { 0xA75D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA75C, result.begin()); + EXPECT_EQ(result, expected) << 0xA75C << " 0xA75C"; + } + { + std::array const expected = { 0xA75F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA75E, result.begin()); + EXPECT_EQ(result, expected) << 0xA75E << " 0xA75E"; + } + { + std::array const expected = { 0xA761, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA760, result.begin()); + EXPECT_EQ(result, expected) << 0xA760 << " 0xA760"; + } + { + std::array const expected = { 0xA763, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA762, result.begin()); + EXPECT_EQ(result, expected) << 0xA762 << " 0xA762"; + } + { + std::array const expected = { 0xA765, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA764, result.begin()); + EXPECT_EQ(result, expected) << 0xA764 << " 0xA764"; + } +} + +TEST(case_folding, test_22) { + { + std::array const expected = { 0xA767, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA766, result.begin()); + EXPECT_EQ(result, expected) << 0xA766 << " 0xA766"; + } + { + std::array const expected = { 0xA769, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA768, result.begin()); + EXPECT_EQ(result, expected) << 0xA768 << " 0xA768"; + } + { + std::array const expected = { 0xA76B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA76A, result.begin()); + EXPECT_EQ(result, expected) << 0xA76A << " 0xA76A"; + } + { + std::array const expected = { 0xA76D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA76C, result.begin()); + EXPECT_EQ(result, expected) << 0xA76C << " 0xA76C"; + } + { + std::array const expected = { 0xA76F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA76E, result.begin()); + EXPECT_EQ(result, expected) << 0xA76E << " 0xA76E"; + } + { + std::array const expected = { 0xA77A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA779, result.begin()); + EXPECT_EQ(result, expected) << 0xA779 << " 0xA779"; + } + { + std::array const expected = { 0xA77C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA77B, result.begin()); + EXPECT_EQ(result, expected) << 0xA77B << " 0xA77B"; + } + { + std::array const expected = { 0x1D79, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA77D, result.begin()); + EXPECT_EQ(result, expected) << 0xA77D << " 0xA77D"; + } + { + std::array const expected = { 0xA77F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA77E, result.begin()); + EXPECT_EQ(result, expected) << 0xA77E << " 0xA77E"; + } + { + std::array const expected = { 0xA781, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA780, result.begin()); + EXPECT_EQ(result, expected) << 0xA780 << " 0xA780"; + } + { + std::array const expected = { 0xA783, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA782, result.begin()); + EXPECT_EQ(result, expected) << 0xA782 << " 0xA782"; + } + { + std::array const expected = { 0xA785, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA784, result.begin()); + EXPECT_EQ(result, expected) << 0xA784 << " 0xA784"; + } + { + std::array const expected = { 0xA787, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA786, result.begin()); + EXPECT_EQ(result, expected) << 0xA786 << " 0xA786"; + } + { + std::array const expected = { 0xA78C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA78B, result.begin()); + EXPECT_EQ(result, expected) << 0xA78B << " 0xA78B"; + } + { + std::array const expected = { 0x0265, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA78D, result.begin()); + EXPECT_EQ(result, expected) << 0xA78D << " 0xA78D"; + } + { + std::array const expected = { 0xA791, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA790, result.begin()); + EXPECT_EQ(result, expected) << 0xA790 << " 0xA790"; + } + { + std::array const expected = { 0xA793, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA792, result.begin()); + EXPECT_EQ(result, expected) << 0xA792 << " 0xA792"; + } + { + std::array const expected = { 0xA797, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA796, result.begin()); + EXPECT_EQ(result, expected) << 0xA796 << " 0xA796"; + } + { + std::array const expected = { 0xA799, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA798, result.begin()); + EXPECT_EQ(result, expected) << 0xA798 << " 0xA798"; + } + { + std::array const expected = { 0xA79B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA79A, result.begin()); + EXPECT_EQ(result, expected) << 0xA79A << " 0xA79A"; + } + { + std::array const expected = { 0xA79D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA79C, result.begin()); + EXPECT_EQ(result, expected) << 0xA79C << " 0xA79C"; + } + { + std::array const expected = { 0xA79F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA79E, result.begin()); + EXPECT_EQ(result, expected) << 0xA79E << " 0xA79E"; + } + { + std::array const expected = { 0xA7A1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7A0, result.begin()); + EXPECT_EQ(result, expected) << 0xA7A0 << " 0xA7A0"; + } + { + std::array const expected = { 0xA7A3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7A2, result.begin()); + EXPECT_EQ(result, expected) << 0xA7A2 << " 0xA7A2"; + } + { + std::array const expected = { 0xA7A5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7A4, result.begin()); + EXPECT_EQ(result, expected) << 0xA7A4 << " 0xA7A4"; + } + { + std::array const expected = { 0xA7A7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7A6, result.begin()); + EXPECT_EQ(result, expected) << 0xA7A6 << " 0xA7A6"; + } + { + std::array const expected = { 0xA7A9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7A8, result.begin()); + EXPECT_EQ(result, expected) << 0xA7A8 << " 0xA7A8"; + } + { + std::array const expected = { 0x0266, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7AA, result.begin()); + EXPECT_EQ(result, expected) << 0xA7AA << " 0xA7AA"; + } + { + std::array const expected = { 0x025C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7AB, result.begin()); + EXPECT_EQ(result, expected) << 0xA7AB << " 0xA7AB"; + } + { + std::array const expected = { 0x0261, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7AC, result.begin()); + EXPECT_EQ(result, expected) << 0xA7AC << " 0xA7AC"; + } + { + std::array const expected = { 0x026C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7AD, result.begin()); + EXPECT_EQ(result, expected) << 0xA7AD << " 0xA7AD"; + } + { + std::array const expected = { 0x026A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7AE, result.begin()); + EXPECT_EQ(result, expected) << 0xA7AE << " 0xA7AE"; + } + { + std::array const expected = { 0x029E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7B0, result.begin()); + EXPECT_EQ(result, expected) << 0xA7B0 << " 0xA7B0"; + } + { + std::array const expected = { 0x0287, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7B1, result.begin()); + EXPECT_EQ(result, expected) << 0xA7B1 << " 0xA7B1"; + } + { + std::array const expected = { 0x029D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7B2, result.begin()); + EXPECT_EQ(result, expected) << 0xA7B2 << " 0xA7B2"; + } + { + std::array const expected = { 0xAB53, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7B3, result.begin()); + EXPECT_EQ(result, expected) << 0xA7B3 << " 0xA7B3"; + } + { + std::array const expected = { 0xA7B5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7B4, result.begin()); + EXPECT_EQ(result, expected) << 0xA7B4 << " 0xA7B4"; + } + { + std::array const expected = { 0xA7B7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7B6, result.begin()); + EXPECT_EQ(result, expected) << 0xA7B6 << " 0xA7B6"; + } + { + std::array const expected = { 0xA7B9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7B8, result.begin()); + EXPECT_EQ(result, expected) << 0xA7B8 << " 0xA7B8"; + } + { + std::array const expected = { 0xA7BB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7BA, result.begin()); + EXPECT_EQ(result, expected) << 0xA7BA << " 0xA7BA"; + } + { + std::array const expected = { 0xA7BD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7BC, result.begin()); + EXPECT_EQ(result, expected) << 0xA7BC << " 0xA7BC"; + } + { + std::array const expected = { 0xA7BF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7BE, result.begin()); + EXPECT_EQ(result, expected) << 0xA7BE << " 0xA7BE"; + } + { + std::array const expected = { 0xA7C1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7C0, result.begin()); + EXPECT_EQ(result, expected) << 0xA7C0 << " 0xA7C0"; + } + { + std::array const expected = { 0xA7C3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7C2, result.begin()); + EXPECT_EQ(result, expected) << 0xA7C2 << " 0xA7C2"; + } + { + std::array const expected = { 0xA794, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7C4, result.begin()); + EXPECT_EQ(result, expected) << 0xA7C4 << " 0xA7C4"; + } + { + std::array const expected = { 0x0282, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7C5, result.begin()); + EXPECT_EQ(result, expected) << 0xA7C5 << " 0xA7C5"; + } + { + std::array const expected = { 0x1D8E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7C6, result.begin()); + EXPECT_EQ(result, expected) << 0xA7C6 << " 0xA7C6"; + } + { + std::array const expected = { 0xA7C8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7C7, result.begin()); + EXPECT_EQ(result, expected) << 0xA7C7 << " 0xA7C7"; + } + { + std::array const expected = { 0xA7CA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7C9, result.begin()); + EXPECT_EQ(result, expected) << 0xA7C9 << " 0xA7C9"; + } + { + std::array const expected = { 0xA7D1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7D0, result.begin()); + EXPECT_EQ(result, expected) << 0xA7D0 << " 0xA7D0"; + } +} + +TEST(case_folding, test_23) { + { + std::array const expected = { 0xA7D7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7D6, result.begin()); + EXPECT_EQ(result, expected) << 0xA7D6 << " 0xA7D6"; + } + { + std::array const expected = { 0xA7D9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7D8, result.begin()); + EXPECT_EQ(result, expected) << 0xA7D8 << " 0xA7D8"; + } + { + std::array const expected = { 0xA7F6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xA7F5, result.begin()); + EXPECT_EQ(result, expected) << 0xA7F5 << " 0xA7F5"; + } + { + std::array const expected = { 0x13A0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB70, result.begin()); + EXPECT_EQ(result, expected) << 0xAB70 << " 0xAB70"; + } + { + std::array const expected = { 0x13A1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB71, result.begin()); + EXPECT_EQ(result, expected) << 0xAB71 << " 0xAB71"; + } + { + std::array const expected = { 0x13A2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB72, result.begin()); + EXPECT_EQ(result, expected) << 0xAB72 << " 0xAB72"; + } + { + std::array const expected = { 0x13A3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB73, result.begin()); + EXPECT_EQ(result, expected) << 0xAB73 << " 0xAB73"; + } + { + std::array const expected = { 0x13A4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB74, result.begin()); + EXPECT_EQ(result, expected) << 0xAB74 << " 0xAB74"; + } + { + std::array const expected = { 0x13A5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB75, result.begin()); + EXPECT_EQ(result, expected) << 0xAB75 << " 0xAB75"; + } + { + std::array const expected = { 0x13A6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB76, result.begin()); + EXPECT_EQ(result, expected) << 0xAB76 << " 0xAB76"; + } + { + std::array const expected = { 0x13A7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB77, result.begin()); + EXPECT_EQ(result, expected) << 0xAB77 << " 0xAB77"; + } + { + std::array const expected = { 0x13A8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB78, result.begin()); + EXPECT_EQ(result, expected) << 0xAB78 << " 0xAB78"; + } + { + std::array const expected = { 0x13A9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB79, result.begin()); + EXPECT_EQ(result, expected) << 0xAB79 << " 0xAB79"; + } + { + std::array const expected = { 0x13AA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB7A, result.begin()); + EXPECT_EQ(result, expected) << 0xAB7A << " 0xAB7A"; + } + { + std::array const expected = { 0x13AB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB7B, result.begin()); + EXPECT_EQ(result, expected) << 0xAB7B << " 0xAB7B"; + } + { + std::array const expected = { 0x13AC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB7C, result.begin()); + EXPECT_EQ(result, expected) << 0xAB7C << " 0xAB7C"; + } + { + std::array const expected = { 0x13AD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB7D, result.begin()); + EXPECT_EQ(result, expected) << 0xAB7D << " 0xAB7D"; + } + { + std::array const expected = { 0x13AE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB7E, result.begin()); + EXPECT_EQ(result, expected) << 0xAB7E << " 0xAB7E"; + } + { + std::array const expected = { 0x13AF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB7F, result.begin()); + EXPECT_EQ(result, expected) << 0xAB7F << " 0xAB7F"; + } + { + std::array const expected = { 0x13B0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB80, result.begin()); + EXPECT_EQ(result, expected) << 0xAB80 << " 0xAB80"; + } + { + std::array const expected = { 0x13B1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB81, result.begin()); + EXPECT_EQ(result, expected) << 0xAB81 << " 0xAB81"; + } + { + std::array const expected = { 0x13B2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB82, result.begin()); + EXPECT_EQ(result, expected) << 0xAB82 << " 0xAB82"; + } + { + std::array const expected = { 0x13B3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB83, result.begin()); + EXPECT_EQ(result, expected) << 0xAB83 << " 0xAB83"; + } + { + std::array const expected = { 0x13B4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB84, result.begin()); + EXPECT_EQ(result, expected) << 0xAB84 << " 0xAB84"; + } + { + std::array const expected = { 0x13B5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB85, result.begin()); + EXPECT_EQ(result, expected) << 0xAB85 << " 0xAB85"; + } + { + std::array const expected = { 0x13B6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB86, result.begin()); + EXPECT_EQ(result, expected) << 0xAB86 << " 0xAB86"; + } + { + std::array const expected = { 0x13B7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB87, result.begin()); + EXPECT_EQ(result, expected) << 0xAB87 << " 0xAB87"; + } + { + std::array const expected = { 0x13B8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB88, result.begin()); + EXPECT_EQ(result, expected) << 0xAB88 << " 0xAB88"; + } + { + std::array const expected = { 0x13B9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB89, result.begin()); + EXPECT_EQ(result, expected) << 0xAB89 << " 0xAB89"; + } + { + std::array const expected = { 0x13BA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB8A, result.begin()); + EXPECT_EQ(result, expected) << 0xAB8A << " 0xAB8A"; + } + { + std::array const expected = { 0x13BB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB8B, result.begin()); + EXPECT_EQ(result, expected) << 0xAB8B << " 0xAB8B"; + } + { + std::array const expected = { 0x13BC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB8C, result.begin()); + EXPECT_EQ(result, expected) << 0xAB8C << " 0xAB8C"; + } + { + std::array const expected = { 0x13BD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB8D, result.begin()); + EXPECT_EQ(result, expected) << 0xAB8D << " 0xAB8D"; + } + { + std::array const expected = { 0x13BE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB8E, result.begin()); + EXPECT_EQ(result, expected) << 0xAB8E << " 0xAB8E"; + } + { + std::array const expected = { 0x13BF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB8F, result.begin()); + EXPECT_EQ(result, expected) << 0xAB8F << " 0xAB8F"; + } + { + std::array const expected = { 0x13C0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB90, result.begin()); + EXPECT_EQ(result, expected) << 0xAB90 << " 0xAB90"; + } + { + std::array const expected = { 0x13C1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB91, result.begin()); + EXPECT_EQ(result, expected) << 0xAB91 << " 0xAB91"; + } + { + std::array const expected = { 0x13C2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB92, result.begin()); + EXPECT_EQ(result, expected) << 0xAB92 << " 0xAB92"; + } + { + std::array const expected = { 0x13C3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB93, result.begin()); + EXPECT_EQ(result, expected) << 0xAB93 << " 0xAB93"; + } + { + std::array const expected = { 0x13C4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB94, result.begin()); + EXPECT_EQ(result, expected) << 0xAB94 << " 0xAB94"; + } + { + std::array const expected = { 0x13C5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB95, result.begin()); + EXPECT_EQ(result, expected) << 0xAB95 << " 0xAB95"; + } + { + std::array const expected = { 0x13C6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB96, result.begin()); + EXPECT_EQ(result, expected) << 0xAB96 << " 0xAB96"; + } + { + std::array const expected = { 0x13C7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB97, result.begin()); + EXPECT_EQ(result, expected) << 0xAB97 << " 0xAB97"; + } + { + std::array const expected = { 0x13C8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB98, result.begin()); + EXPECT_EQ(result, expected) << 0xAB98 << " 0xAB98"; + } + { + std::array const expected = { 0x13C9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB99, result.begin()); + EXPECT_EQ(result, expected) << 0xAB99 << " 0xAB99"; + } + { + std::array const expected = { 0x13CA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB9A, result.begin()); + EXPECT_EQ(result, expected) << 0xAB9A << " 0xAB9A"; + } + { + std::array const expected = { 0x13CB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB9B, result.begin()); + EXPECT_EQ(result, expected) << 0xAB9B << " 0xAB9B"; + } + { + std::array const expected = { 0x13CC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB9C, result.begin()); + EXPECT_EQ(result, expected) << 0xAB9C << " 0xAB9C"; + } + { + std::array const expected = { 0x13CD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB9D, result.begin()); + EXPECT_EQ(result, expected) << 0xAB9D << " 0xAB9D"; + } + { + std::array const expected = { 0x13CE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB9E, result.begin()); + EXPECT_EQ(result, expected) << 0xAB9E << " 0xAB9E"; + } +} + +TEST(case_folding, test_24) { + { + std::array const expected = { 0x13CF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xAB9F, result.begin()); + EXPECT_EQ(result, expected) << 0xAB9F << " 0xAB9F"; + } + { + std::array const expected = { 0x13D0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABA0, result.begin()); + EXPECT_EQ(result, expected) << 0xABA0 << " 0xABA0"; + } + { + std::array const expected = { 0x13D1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABA1, result.begin()); + EXPECT_EQ(result, expected) << 0xABA1 << " 0xABA1"; + } + { + std::array const expected = { 0x13D2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABA2, result.begin()); + EXPECT_EQ(result, expected) << 0xABA2 << " 0xABA2"; + } + { + std::array const expected = { 0x13D3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABA3, result.begin()); + EXPECT_EQ(result, expected) << 0xABA3 << " 0xABA3"; + } + { + std::array const expected = { 0x13D4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABA4, result.begin()); + EXPECT_EQ(result, expected) << 0xABA4 << " 0xABA4"; + } + { + std::array const expected = { 0x13D5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABA5, result.begin()); + EXPECT_EQ(result, expected) << 0xABA5 << " 0xABA5"; + } + { + std::array const expected = { 0x13D6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABA6, result.begin()); + EXPECT_EQ(result, expected) << 0xABA6 << " 0xABA6"; + } + { + std::array const expected = { 0x13D7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABA7, result.begin()); + EXPECT_EQ(result, expected) << 0xABA7 << " 0xABA7"; + } + { + std::array const expected = { 0x13D8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABA8, result.begin()); + EXPECT_EQ(result, expected) << 0xABA8 << " 0xABA8"; + } + { + std::array const expected = { 0x13D9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABA9, result.begin()); + EXPECT_EQ(result, expected) << 0xABA9 << " 0xABA9"; + } + { + std::array const expected = { 0x13DA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABAA, result.begin()); + EXPECT_EQ(result, expected) << 0xABAA << " 0xABAA"; + } + { + std::array const expected = { 0x13DB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABAB, result.begin()); + EXPECT_EQ(result, expected) << 0xABAB << " 0xABAB"; + } + { + std::array const expected = { 0x13DC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABAC, result.begin()); + EXPECT_EQ(result, expected) << 0xABAC << " 0xABAC"; + } + { + std::array const expected = { 0x13DD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABAD, result.begin()); + EXPECT_EQ(result, expected) << 0xABAD << " 0xABAD"; + } + { + std::array const expected = { 0x13DE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABAE, result.begin()); + EXPECT_EQ(result, expected) << 0xABAE << " 0xABAE"; + } + { + std::array const expected = { 0x13DF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABAF, result.begin()); + EXPECT_EQ(result, expected) << 0xABAF << " 0xABAF"; + } + { + std::array const expected = { 0x13E0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABB0, result.begin()); + EXPECT_EQ(result, expected) << 0xABB0 << " 0xABB0"; + } + { + std::array const expected = { 0x13E1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABB1, result.begin()); + EXPECT_EQ(result, expected) << 0xABB1 << " 0xABB1"; + } + { + std::array const expected = { 0x13E2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABB2, result.begin()); + EXPECT_EQ(result, expected) << 0xABB2 << " 0xABB2"; + } + { + std::array const expected = { 0x13E3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABB3, result.begin()); + EXPECT_EQ(result, expected) << 0xABB3 << " 0xABB3"; + } + { + std::array const expected = { 0x13E4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABB4, result.begin()); + EXPECT_EQ(result, expected) << 0xABB4 << " 0xABB4"; + } + { + std::array const expected = { 0x13E5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABB5, result.begin()); + EXPECT_EQ(result, expected) << 0xABB5 << " 0xABB5"; + } + { + std::array const expected = { 0x13E6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABB6, result.begin()); + EXPECT_EQ(result, expected) << 0xABB6 << " 0xABB6"; + } + { + std::array const expected = { 0x13E7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABB7, result.begin()); + EXPECT_EQ(result, expected) << 0xABB7 << " 0xABB7"; + } + { + std::array const expected = { 0x13E8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABB8, result.begin()); + EXPECT_EQ(result, expected) << 0xABB8 << " 0xABB8"; + } + { + std::array const expected = { 0x13E9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABB9, result.begin()); + EXPECT_EQ(result, expected) << 0xABB9 << " 0xABB9"; + } + { + std::array const expected = { 0x13EA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABBA, result.begin()); + EXPECT_EQ(result, expected) << 0xABBA << " 0xABBA"; + } + { + std::array const expected = { 0x13EB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABBB, result.begin()); + EXPECT_EQ(result, expected) << 0xABBB << " 0xABBB"; + } + { + std::array const expected = { 0x13EC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABBC, result.begin()); + EXPECT_EQ(result, expected) << 0xABBC << " 0xABBC"; + } + { + std::array const expected = { 0x13ED, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABBD, result.begin()); + EXPECT_EQ(result, expected) << 0xABBD << " 0xABBD"; + } + { + std::array const expected = { 0x13EE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABBE, result.begin()); + EXPECT_EQ(result, expected) << 0xABBE << " 0xABBE"; + } + { + std::array const expected = { 0x13EF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xABBF, result.begin()); + EXPECT_EQ(result, expected) << 0xABBF << " 0xABBF"; + } + { + std::array const expected = { 0x0066, 0x0066, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFB00, result.begin()); + EXPECT_EQ(result, expected) << 0xFB00 << " 0xFB00"; + } + { + std::array const expected = { 0x0066, 0x0069, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFB01, result.begin()); + EXPECT_EQ(result, expected) << 0xFB01 << " 0xFB01"; + } + { + std::array const expected = { 0x0066, 0x006C, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFB02, result.begin()); + EXPECT_EQ(result, expected) << 0xFB02 << " 0xFB02"; + } + { + std::array const expected = { 0x0066, 0x0066, 0x0069, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFB03, result.begin()); + EXPECT_EQ(result, expected) << 0xFB03 << " 0xFB03"; + } + { + std::array const expected = { 0x0066, 0x0066, 0x006C, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFB04, result.begin()); + EXPECT_EQ(result, expected) << 0xFB04 << " 0xFB04"; + } + { + std::array const expected = { 0x0073, 0x0074, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFB05, result.begin()); + EXPECT_EQ(result, expected) << 0xFB05 << " 0xFB05"; + } + { + std::array const expected = { 0x0073, 0x0074, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFB06, result.begin()); + EXPECT_EQ(result, expected) << 0xFB06 << " 0xFB06"; + } + { + std::array const expected = { 0x0574, 0x0576, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFB13, result.begin()); + EXPECT_EQ(result, expected) << 0xFB13 << " 0xFB13"; + } + { + std::array const expected = { 0x0574, 0x0565, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFB14, result.begin()); + EXPECT_EQ(result, expected) << 0xFB14 << " 0xFB14"; + } + { + std::array const expected = { 0x0574, 0x056B, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFB15, result.begin()); + EXPECT_EQ(result, expected) << 0xFB15 << " 0xFB15"; + } + { + std::array const expected = { 0x057E, 0x0576, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFB16, result.begin()); + EXPECT_EQ(result, expected) << 0xFB16 << " 0xFB16"; + } + { + std::array const expected = { 0x0574, 0x056D, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFB17, result.begin()); + EXPECT_EQ(result, expected) << 0xFB17 << " 0xFB17"; + } + { + std::array const expected = { 0xFF41, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF21, result.begin()); + EXPECT_EQ(result, expected) << 0xFF21 << " 0xFF21"; + } + { + std::array const expected = { 0xFF42, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF22, result.begin()); + EXPECT_EQ(result, expected) << 0xFF22 << " 0xFF22"; + } + { + std::array const expected = { 0xFF43, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF23, result.begin()); + EXPECT_EQ(result, expected) << 0xFF23 << " 0xFF23"; + } + { + std::array const expected = { 0xFF44, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF24, result.begin()); + EXPECT_EQ(result, expected) << 0xFF24 << " 0xFF24"; + } + { + std::array const expected = { 0xFF45, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF25, result.begin()); + EXPECT_EQ(result, expected) << 0xFF25 << " 0xFF25"; + } +} + +TEST(case_folding, test_25) { + { + std::array const expected = { 0xFF46, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF26, result.begin()); + EXPECT_EQ(result, expected) << 0xFF26 << " 0xFF26"; + } + { + std::array const expected = { 0xFF47, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF27, result.begin()); + EXPECT_EQ(result, expected) << 0xFF27 << " 0xFF27"; + } + { + std::array const expected = { 0xFF48, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF28, result.begin()); + EXPECT_EQ(result, expected) << 0xFF28 << " 0xFF28"; + } + { + std::array const expected = { 0xFF49, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF29, result.begin()); + EXPECT_EQ(result, expected) << 0xFF29 << " 0xFF29"; + } + { + std::array const expected = { 0xFF4A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF2A, result.begin()); + EXPECT_EQ(result, expected) << 0xFF2A << " 0xFF2A"; + } + { + std::array const expected = { 0xFF4B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF2B, result.begin()); + EXPECT_EQ(result, expected) << 0xFF2B << " 0xFF2B"; + } + { + std::array const expected = { 0xFF4C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF2C, result.begin()); + EXPECT_EQ(result, expected) << 0xFF2C << " 0xFF2C"; + } + { + std::array const expected = { 0xFF4D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF2D, result.begin()); + EXPECT_EQ(result, expected) << 0xFF2D << " 0xFF2D"; + } + { + std::array const expected = { 0xFF4E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF2E, result.begin()); + EXPECT_EQ(result, expected) << 0xFF2E << " 0xFF2E"; + } + { + std::array const expected = { 0xFF4F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF2F, result.begin()); + EXPECT_EQ(result, expected) << 0xFF2F << " 0xFF2F"; + } + { + std::array const expected = { 0xFF50, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF30, result.begin()); + EXPECT_EQ(result, expected) << 0xFF30 << " 0xFF30"; + } + { + std::array const expected = { 0xFF51, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF31, result.begin()); + EXPECT_EQ(result, expected) << 0xFF31 << " 0xFF31"; + } + { + std::array const expected = { 0xFF52, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF32, result.begin()); + EXPECT_EQ(result, expected) << 0xFF32 << " 0xFF32"; + } + { + std::array const expected = { 0xFF53, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF33, result.begin()); + EXPECT_EQ(result, expected) << 0xFF33 << " 0xFF33"; + } + { + std::array const expected = { 0xFF54, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF34, result.begin()); + EXPECT_EQ(result, expected) << 0xFF34 << " 0xFF34"; + } + { + std::array const expected = { 0xFF55, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF35, result.begin()); + EXPECT_EQ(result, expected) << 0xFF35 << " 0xFF35"; + } + { + std::array const expected = { 0xFF56, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF36, result.begin()); + EXPECT_EQ(result, expected) << 0xFF36 << " 0xFF36"; + } + { + std::array const expected = { 0xFF57, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF37, result.begin()); + EXPECT_EQ(result, expected) << 0xFF37 << " 0xFF37"; + } + { + std::array const expected = { 0xFF58, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF38, result.begin()); + EXPECT_EQ(result, expected) << 0xFF38 << " 0xFF38"; + } + { + std::array const expected = { 0xFF59, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF39, result.begin()); + EXPECT_EQ(result, expected) << 0xFF39 << " 0xFF39"; + } + { + std::array const expected = { 0xFF5A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0xFF3A, result.begin()); + EXPECT_EQ(result, expected) << 0xFF3A << " 0xFF3A"; + } + { + std::array const expected = { 0x10428, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10400, result.begin()); + EXPECT_EQ(result, expected) << 0x10400 << " 0x10400"; + } + { + std::array const expected = { 0x10429, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10401, result.begin()); + EXPECT_EQ(result, expected) << 0x10401 << " 0x10401"; + } + { + std::array const expected = { 0x1042A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10402, result.begin()); + EXPECT_EQ(result, expected) << 0x10402 << " 0x10402"; + } + { + std::array const expected = { 0x1042B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10403, result.begin()); + EXPECT_EQ(result, expected) << 0x10403 << " 0x10403"; + } + { + std::array const expected = { 0x1042C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10404, result.begin()); + EXPECT_EQ(result, expected) << 0x10404 << " 0x10404"; + } + { + std::array const expected = { 0x1042D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10405, result.begin()); + EXPECT_EQ(result, expected) << 0x10405 << " 0x10405"; + } + { + std::array const expected = { 0x1042E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10406, result.begin()); + EXPECT_EQ(result, expected) << 0x10406 << " 0x10406"; + } + { + std::array const expected = { 0x1042F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10407, result.begin()); + EXPECT_EQ(result, expected) << 0x10407 << " 0x10407"; + } + { + std::array const expected = { 0x10430, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10408, result.begin()); + EXPECT_EQ(result, expected) << 0x10408 << " 0x10408"; + } + { + std::array const expected = { 0x10431, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10409, result.begin()); + EXPECT_EQ(result, expected) << 0x10409 << " 0x10409"; + } + { + std::array const expected = { 0x10432, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1040A, result.begin()); + EXPECT_EQ(result, expected) << 0x1040A << " 0x1040A"; + } + { + std::array const expected = { 0x10433, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1040B, result.begin()); + EXPECT_EQ(result, expected) << 0x1040B << " 0x1040B"; + } + { + std::array const expected = { 0x10434, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1040C, result.begin()); + EXPECT_EQ(result, expected) << 0x1040C << " 0x1040C"; + } + { + std::array const expected = { 0x10435, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1040D, result.begin()); + EXPECT_EQ(result, expected) << 0x1040D << " 0x1040D"; + } + { + std::array const expected = { 0x10436, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1040E, result.begin()); + EXPECT_EQ(result, expected) << 0x1040E << " 0x1040E"; + } + { + std::array const expected = { 0x10437, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1040F, result.begin()); + EXPECT_EQ(result, expected) << 0x1040F << " 0x1040F"; + } + { + std::array const expected = { 0x10438, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10410, result.begin()); + EXPECT_EQ(result, expected) << 0x10410 << " 0x10410"; + } + { + std::array const expected = { 0x10439, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10411, result.begin()); + EXPECT_EQ(result, expected) << 0x10411 << " 0x10411"; + } + { + std::array const expected = { 0x1043A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10412, result.begin()); + EXPECT_EQ(result, expected) << 0x10412 << " 0x10412"; + } + { + std::array const expected = { 0x1043B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10413, result.begin()); + EXPECT_EQ(result, expected) << 0x10413 << " 0x10413"; + } + { + std::array const expected = { 0x1043C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10414, result.begin()); + EXPECT_EQ(result, expected) << 0x10414 << " 0x10414"; + } + { + std::array const expected = { 0x1043D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10415, result.begin()); + EXPECT_EQ(result, expected) << 0x10415 << " 0x10415"; + } + { + std::array const expected = { 0x1043E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10416, result.begin()); + EXPECT_EQ(result, expected) << 0x10416 << " 0x10416"; + } + { + std::array const expected = { 0x1043F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10417, result.begin()); + EXPECT_EQ(result, expected) << 0x10417 << " 0x10417"; + } + { + std::array const expected = { 0x10440, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10418, result.begin()); + EXPECT_EQ(result, expected) << 0x10418 << " 0x10418"; + } + { + std::array const expected = { 0x10441, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10419, result.begin()); + EXPECT_EQ(result, expected) << 0x10419 << " 0x10419"; + } + { + std::array const expected = { 0x10442, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1041A, result.begin()); + EXPECT_EQ(result, expected) << 0x1041A << " 0x1041A"; + } + { + std::array const expected = { 0x10443, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1041B, result.begin()); + EXPECT_EQ(result, expected) << 0x1041B << " 0x1041B"; + } + { + std::array const expected = { 0x10444, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1041C, result.begin()); + EXPECT_EQ(result, expected) << 0x1041C << " 0x1041C"; + } +} + +TEST(case_folding, test_26) { + { + std::array const expected = { 0x10445, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1041D, result.begin()); + EXPECT_EQ(result, expected) << 0x1041D << " 0x1041D"; + } + { + std::array const expected = { 0x10446, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1041E, result.begin()); + EXPECT_EQ(result, expected) << 0x1041E << " 0x1041E"; + } + { + std::array const expected = { 0x10447, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1041F, result.begin()); + EXPECT_EQ(result, expected) << 0x1041F << " 0x1041F"; + } + { + std::array const expected = { 0x10448, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10420, result.begin()); + EXPECT_EQ(result, expected) << 0x10420 << " 0x10420"; + } + { + std::array const expected = { 0x10449, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10421, result.begin()); + EXPECT_EQ(result, expected) << 0x10421 << " 0x10421"; + } + { + std::array const expected = { 0x1044A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10422, result.begin()); + EXPECT_EQ(result, expected) << 0x10422 << " 0x10422"; + } + { + std::array const expected = { 0x1044B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10423, result.begin()); + EXPECT_EQ(result, expected) << 0x10423 << " 0x10423"; + } + { + std::array const expected = { 0x1044C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10424, result.begin()); + EXPECT_EQ(result, expected) << 0x10424 << " 0x10424"; + } + { + std::array const expected = { 0x1044D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10425, result.begin()); + EXPECT_EQ(result, expected) << 0x10425 << " 0x10425"; + } + { + std::array const expected = { 0x1044E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10426, result.begin()); + EXPECT_EQ(result, expected) << 0x10426 << " 0x10426"; + } + { + std::array const expected = { 0x1044F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10427, result.begin()); + EXPECT_EQ(result, expected) << 0x10427 << " 0x10427"; + } + { + std::array const expected = { 0x104D8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104B0, result.begin()); + EXPECT_EQ(result, expected) << 0x104B0 << " 0x104B0"; + } + { + std::array const expected = { 0x104D9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104B1, result.begin()); + EXPECT_EQ(result, expected) << 0x104B1 << " 0x104B1"; + } + { + std::array const expected = { 0x104DA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104B2, result.begin()); + EXPECT_EQ(result, expected) << 0x104B2 << " 0x104B2"; + } + { + std::array const expected = { 0x104DB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104B3, result.begin()); + EXPECT_EQ(result, expected) << 0x104B3 << " 0x104B3"; + } + { + std::array const expected = { 0x104DC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104B4, result.begin()); + EXPECT_EQ(result, expected) << 0x104B4 << " 0x104B4"; + } + { + std::array const expected = { 0x104DD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104B5, result.begin()); + EXPECT_EQ(result, expected) << 0x104B5 << " 0x104B5"; + } + { + std::array const expected = { 0x104DE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104B6, result.begin()); + EXPECT_EQ(result, expected) << 0x104B6 << " 0x104B6"; + } + { + std::array const expected = { 0x104DF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104B7, result.begin()); + EXPECT_EQ(result, expected) << 0x104B7 << " 0x104B7"; + } + { + std::array const expected = { 0x104E0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104B8, result.begin()); + EXPECT_EQ(result, expected) << 0x104B8 << " 0x104B8"; + } + { + std::array const expected = { 0x104E1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104B9, result.begin()); + EXPECT_EQ(result, expected) << 0x104B9 << " 0x104B9"; + } + { + std::array const expected = { 0x104E2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104BA, result.begin()); + EXPECT_EQ(result, expected) << 0x104BA << " 0x104BA"; + } + { + std::array const expected = { 0x104E3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104BB, result.begin()); + EXPECT_EQ(result, expected) << 0x104BB << " 0x104BB"; + } + { + std::array const expected = { 0x104E4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104BC, result.begin()); + EXPECT_EQ(result, expected) << 0x104BC << " 0x104BC"; + } + { + std::array const expected = { 0x104E5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104BD, result.begin()); + EXPECT_EQ(result, expected) << 0x104BD << " 0x104BD"; + } + { + std::array const expected = { 0x104E6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104BE, result.begin()); + EXPECT_EQ(result, expected) << 0x104BE << " 0x104BE"; + } + { + std::array const expected = { 0x104E7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104BF, result.begin()); + EXPECT_EQ(result, expected) << 0x104BF << " 0x104BF"; + } + { + std::array const expected = { 0x104E8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104C0, result.begin()); + EXPECT_EQ(result, expected) << 0x104C0 << " 0x104C0"; + } + { + std::array const expected = { 0x104E9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104C1, result.begin()); + EXPECT_EQ(result, expected) << 0x104C1 << " 0x104C1"; + } + { + std::array const expected = { 0x104EA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104C2, result.begin()); + EXPECT_EQ(result, expected) << 0x104C2 << " 0x104C2"; + } + { + std::array const expected = { 0x104EB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104C3, result.begin()); + EXPECT_EQ(result, expected) << 0x104C3 << " 0x104C3"; + } + { + std::array const expected = { 0x104EC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104C4, result.begin()); + EXPECT_EQ(result, expected) << 0x104C4 << " 0x104C4"; + } + { + std::array const expected = { 0x104ED, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104C5, result.begin()); + EXPECT_EQ(result, expected) << 0x104C5 << " 0x104C5"; + } + { + std::array const expected = { 0x104EE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104C6, result.begin()); + EXPECT_EQ(result, expected) << 0x104C6 << " 0x104C6"; + } + { + std::array const expected = { 0x104EF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104C7, result.begin()); + EXPECT_EQ(result, expected) << 0x104C7 << " 0x104C7"; + } + { + std::array const expected = { 0x104F0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104C8, result.begin()); + EXPECT_EQ(result, expected) << 0x104C8 << " 0x104C8"; + } + { + std::array const expected = { 0x104F1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104C9, result.begin()); + EXPECT_EQ(result, expected) << 0x104C9 << " 0x104C9"; + } + { + std::array const expected = { 0x104F2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104CA, result.begin()); + EXPECT_EQ(result, expected) << 0x104CA << " 0x104CA"; + } + { + std::array const expected = { 0x104F3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104CB, result.begin()); + EXPECT_EQ(result, expected) << 0x104CB << " 0x104CB"; + } + { + std::array const expected = { 0x104F4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104CC, result.begin()); + EXPECT_EQ(result, expected) << 0x104CC << " 0x104CC"; + } + { + std::array const expected = { 0x104F5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104CD, result.begin()); + EXPECT_EQ(result, expected) << 0x104CD << " 0x104CD"; + } + { + std::array const expected = { 0x104F6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104CE, result.begin()); + EXPECT_EQ(result, expected) << 0x104CE << " 0x104CE"; + } + { + std::array const expected = { 0x104F7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104CF, result.begin()); + EXPECT_EQ(result, expected) << 0x104CF << " 0x104CF"; + } + { + std::array const expected = { 0x104F8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104D0, result.begin()); + EXPECT_EQ(result, expected) << 0x104D0 << " 0x104D0"; + } + { + std::array const expected = { 0x104F9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104D1, result.begin()); + EXPECT_EQ(result, expected) << 0x104D1 << " 0x104D1"; + } + { + std::array const expected = { 0x104FA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104D2, result.begin()); + EXPECT_EQ(result, expected) << 0x104D2 << " 0x104D2"; + } + { + std::array const expected = { 0x104FB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x104D3, result.begin()); + EXPECT_EQ(result, expected) << 0x104D3 << " 0x104D3"; + } + { + std::array const expected = { 0x10597, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10570, result.begin()); + EXPECT_EQ(result, expected) << 0x10570 << " 0x10570"; + } + { + std::array const expected = { 0x10598, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10571, result.begin()); + EXPECT_EQ(result, expected) << 0x10571 << " 0x10571"; + } + { + std::array const expected = { 0x10599, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10572, result.begin()); + EXPECT_EQ(result, expected) << 0x10572 << " 0x10572"; + } +} + +TEST(case_folding, test_27) { + { + std::array const expected = { 0x1059A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10573, result.begin()); + EXPECT_EQ(result, expected) << 0x10573 << " 0x10573"; + } + { + std::array const expected = { 0x1059B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10574, result.begin()); + EXPECT_EQ(result, expected) << 0x10574 << " 0x10574"; + } + { + std::array const expected = { 0x1059C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10575, result.begin()); + EXPECT_EQ(result, expected) << 0x10575 << " 0x10575"; + } + { + std::array const expected = { 0x1059D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10576, result.begin()); + EXPECT_EQ(result, expected) << 0x10576 << " 0x10576"; + } + { + std::array const expected = { 0x1059E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10577, result.begin()); + EXPECT_EQ(result, expected) << 0x10577 << " 0x10577"; + } + { + std::array const expected = { 0x1059F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10578, result.begin()); + EXPECT_EQ(result, expected) << 0x10578 << " 0x10578"; + } + { + std::array const expected = { 0x105A0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10579, result.begin()); + EXPECT_EQ(result, expected) << 0x10579 << " 0x10579"; + } + { + std::array const expected = { 0x105A1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1057A, result.begin()); + EXPECT_EQ(result, expected) << 0x1057A << " 0x1057A"; + } + { + std::array const expected = { 0x105A3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1057C, result.begin()); + EXPECT_EQ(result, expected) << 0x1057C << " 0x1057C"; + } + { + std::array const expected = { 0x105A4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1057D, result.begin()); + EXPECT_EQ(result, expected) << 0x1057D << " 0x1057D"; + } + { + std::array const expected = { 0x105A5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1057E, result.begin()); + EXPECT_EQ(result, expected) << 0x1057E << " 0x1057E"; + } + { + std::array const expected = { 0x105A6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1057F, result.begin()); + EXPECT_EQ(result, expected) << 0x1057F << " 0x1057F"; + } + { + std::array const expected = { 0x105A7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10580, result.begin()); + EXPECT_EQ(result, expected) << 0x10580 << " 0x10580"; + } + { + std::array const expected = { 0x105A8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10581, result.begin()); + EXPECT_EQ(result, expected) << 0x10581 << " 0x10581"; + } + { + std::array const expected = { 0x105A9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10582, result.begin()); + EXPECT_EQ(result, expected) << 0x10582 << " 0x10582"; + } + { + std::array const expected = { 0x105AA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10583, result.begin()); + EXPECT_EQ(result, expected) << 0x10583 << " 0x10583"; + } + { + std::array const expected = { 0x105AB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10584, result.begin()); + EXPECT_EQ(result, expected) << 0x10584 << " 0x10584"; + } + { + std::array const expected = { 0x105AC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10585, result.begin()); + EXPECT_EQ(result, expected) << 0x10585 << " 0x10585"; + } + { + std::array const expected = { 0x105AD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10586, result.begin()); + EXPECT_EQ(result, expected) << 0x10586 << " 0x10586"; + } + { + std::array const expected = { 0x105AE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10587, result.begin()); + EXPECT_EQ(result, expected) << 0x10587 << " 0x10587"; + } + { + std::array const expected = { 0x105AF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10588, result.begin()); + EXPECT_EQ(result, expected) << 0x10588 << " 0x10588"; + } + { + std::array const expected = { 0x105B0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10589, result.begin()); + EXPECT_EQ(result, expected) << 0x10589 << " 0x10589"; + } + { + std::array const expected = { 0x105B1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1058A, result.begin()); + EXPECT_EQ(result, expected) << 0x1058A << " 0x1058A"; + } + { + std::array const expected = { 0x105B3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1058C, result.begin()); + EXPECT_EQ(result, expected) << 0x1058C << " 0x1058C"; + } + { + std::array const expected = { 0x105B4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1058D, result.begin()); + EXPECT_EQ(result, expected) << 0x1058D << " 0x1058D"; + } + { + std::array const expected = { 0x105B5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1058E, result.begin()); + EXPECT_EQ(result, expected) << 0x1058E << " 0x1058E"; + } + { + std::array const expected = { 0x105B6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1058F, result.begin()); + EXPECT_EQ(result, expected) << 0x1058F << " 0x1058F"; + } + { + std::array const expected = { 0x105B7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10590, result.begin()); + EXPECT_EQ(result, expected) << 0x10590 << " 0x10590"; + } + { + std::array const expected = { 0x105B8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10591, result.begin()); + EXPECT_EQ(result, expected) << 0x10591 << " 0x10591"; + } + { + std::array const expected = { 0x105B9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10592, result.begin()); + EXPECT_EQ(result, expected) << 0x10592 << " 0x10592"; + } + { + std::array const expected = { 0x105BB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10594, result.begin()); + EXPECT_EQ(result, expected) << 0x10594 << " 0x10594"; + } + { + std::array const expected = { 0x105BC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10595, result.begin()); + EXPECT_EQ(result, expected) << 0x10595 << " 0x10595"; + } + { + std::array const expected = { 0x10CC0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C80, result.begin()); + EXPECT_EQ(result, expected) << 0x10C80 << " 0x10C80"; + } + { + std::array const expected = { 0x10CC1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C81, result.begin()); + EXPECT_EQ(result, expected) << 0x10C81 << " 0x10C81"; + } + { + std::array const expected = { 0x10CC2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C82, result.begin()); + EXPECT_EQ(result, expected) << 0x10C82 << " 0x10C82"; + } + { + std::array const expected = { 0x10CC3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C83, result.begin()); + EXPECT_EQ(result, expected) << 0x10C83 << " 0x10C83"; + } + { + std::array const expected = { 0x10CC4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C84, result.begin()); + EXPECT_EQ(result, expected) << 0x10C84 << " 0x10C84"; + } + { + std::array const expected = { 0x10CC5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C85, result.begin()); + EXPECT_EQ(result, expected) << 0x10C85 << " 0x10C85"; + } + { + std::array const expected = { 0x10CC6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C86, result.begin()); + EXPECT_EQ(result, expected) << 0x10C86 << " 0x10C86"; + } + { + std::array const expected = { 0x10CC7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C87, result.begin()); + EXPECT_EQ(result, expected) << 0x10C87 << " 0x10C87"; + } + { + std::array const expected = { 0x10CC8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C88, result.begin()); + EXPECT_EQ(result, expected) << 0x10C88 << " 0x10C88"; + } + { + std::array const expected = { 0x10CC9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C89, result.begin()); + EXPECT_EQ(result, expected) << 0x10C89 << " 0x10C89"; + } + { + std::array const expected = { 0x10CCA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C8A, result.begin()); + EXPECT_EQ(result, expected) << 0x10C8A << " 0x10C8A"; + } + { + std::array const expected = { 0x10CCB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C8B, result.begin()); + EXPECT_EQ(result, expected) << 0x10C8B << " 0x10C8B"; + } + { + std::array const expected = { 0x10CCC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C8C, result.begin()); + EXPECT_EQ(result, expected) << 0x10C8C << " 0x10C8C"; + } + { + std::array const expected = { 0x10CCD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C8D, result.begin()); + EXPECT_EQ(result, expected) << 0x10C8D << " 0x10C8D"; + } + { + std::array const expected = { 0x10CCE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C8E, result.begin()); + EXPECT_EQ(result, expected) << 0x10C8E << " 0x10C8E"; + } + { + std::array const expected = { 0x10CCF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C8F, result.begin()); + EXPECT_EQ(result, expected) << 0x10C8F << " 0x10C8F"; + } + { + std::array const expected = { 0x10CD0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C90, result.begin()); + EXPECT_EQ(result, expected) << 0x10C90 << " 0x10C90"; + } + { + std::array const expected = { 0x10CD1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C91, result.begin()); + EXPECT_EQ(result, expected) << 0x10C91 << " 0x10C91"; + } +} + +TEST(case_folding, test_28) { + { + std::array const expected = { 0x10CD2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C92, result.begin()); + EXPECT_EQ(result, expected) << 0x10C92 << " 0x10C92"; + } + { + std::array const expected = { 0x10CD3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C93, result.begin()); + EXPECT_EQ(result, expected) << 0x10C93 << " 0x10C93"; + } + { + std::array const expected = { 0x10CD4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C94, result.begin()); + EXPECT_EQ(result, expected) << 0x10C94 << " 0x10C94"; + } + { + std::array const expected = { 0x10CD5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C95, result.begin()); + EXPECT_EQ(result, expected) << 0x10C95 << " 0x10C95"; + } + { + std::array const expected = { 0x10CD6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C96, result.begin()); + EXPECT_EQ(result, expected) << 0x10C96 << " 0x10C96"; + } + { + std::array const expected = { 0x10CD7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C97, result.begin()); + EXPECT_EQ(result, expected) << 0x10C97 << " 0x10C97"; + } + { + std::array const expected = { 0x10CD8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C98, result.begin()); + EXPECT_EQ(result, expected) << 0x10C98 << " 0x10C98"; + } + { + std::array const expected = { 0x10CD9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C99, result.begin()); + EXPECT_EQ(result, expected) << 0x10C99 << " 0x10C99"; + } + { + std::array const expected = { 0x10CDA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C9A, result.begin()); + EXPECT_EQ(result, expected) << 0x10C9A << " 0x10C9A"; + } + { + std::array const expected = { 0x10CDB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C9B, result.begin()); + EXPECT_EQ(result, expected) << 0x10C9B << " 0x10C9B"; + } + { + std::array const expected = { 0x10CDC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C9C, result.begin()); + EXPECT_EQ(result, expected) << 0x10C9C << " 0x10C9C"; + } + { + std::array const expected = { 0x10CDD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C9D, result.begin()); + EXPECT_EQ(result, expected) << 0x10C9D << " 0x10C9D"; + } + { + std::array const expected = { 0x10CDE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C9E, result.begin()); + EXPECT_EQ(result, expected) << 0x10C9E << " 0x10C9E"; + } + { + std::array const expected = { 0x10CDF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10C9F, result.begin()); + EXPECT_EQ(result, expected) << 0x10C9F << " 0x10C9F"; + } + { + std::array const expected = { 0x10CE0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CA0, result.begin()); + EXPECT_EQ(result, expected) << 0x10CA0 << " 0x10CA0"; + } + { + std::array const expected = { 0x10CE1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CA1, result.begin()); + EXPECT_EQ(result, expected) << 0x10CA1 << " 0x10CA1"; + } + { + std::array const expected = { 0x10CE2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CA2, result.begin()); + EXPECT_EQ(result, expected) << 0x10CA2 << " 0x10CA2"; + } + { + std::array const expected = { 0x10CE3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CA3, result.begin()); + EXPECT_EQ(result, expected) << 0x10CA3 << " 0x10CA3"; + } + { + std::array const expected = { 0x10CE4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CA4, result.begin()); + EXPECT_EQ(result, expected) << 0x10CA4 << " 0x10CA4"; + } + { + std::array const expected = { 0x10CE5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CA5, result.begin()); + EXPECT_EQ(result, expected) << 0x10CA5 << " 0x10CA5"; + } + { + std::array const expected = { 0x10CE6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CA6, result.begin()); + EXPECT_EQ(result, expected) << 0x10CA6 << " 0x10CA6"; + } + { + std::array const expected = { 0x10CE7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CA7, result.begin()); + EXPECT_EQ(result, expected) << 0x10CA7 << " 0x10CA7"; + } + { + std::array const expected = { 0x10CE8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CA8, result.begin()); + EXPECT_EQ(result, expected) << 0x10CA8 << " 0x10CA8"; + } + { + std::array const expected = { 0x10CE9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CA9, result.begin()); + EXPECT_EQ(result, expected) << 0x10CA9 << " 0x10CA9"; + } + { + std::array const expected = { 0x10CEA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CAA, result.begin()); + EXPECT_EQ(result, expected) << 0x10CAA << " 0x10CAA"; + } + { + std::array const expected = { 0x10CEB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CAB, result.begin()); + EXPECT_EQ(result, expected) << 0x10CAB << " 0x10CAB"; + } + { + std::array const expected = { 0x10CEC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CAC, result.begin()); + EXPECT_EQ(result, expected) << 0x10CAC << " 0x10CAC"; + } + { + std::array const expected = { 0x10CED, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CAD, result.begin()); + EXPECT_EQ(result, expected) << 0x10CAD << " 0x10CAD"; + } + { + std::array const expected = { 0x10CEE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CAE, result.begin()); + EXPECT_EQ(result, expected) << 0x10CAE << " 0x10CAE"; + } + { + std::array const expected = { 0x10CEF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CAF, result.begin()); + EXPECT_EQ(result, expected) << 0x10CAF << " 0x10CAF"; + } + { + std::array const expected = { 0x10CF0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CB0, result.begin()); + EXPECT_EQ(result, expected) << 0x10CB0 << " 0x10CB0"; + } + { + std::array const expected = { 0x10CF1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CB1, result.begin()); + EXPECT_EQ(result, expected) << 0x10CB1 << " 0x10CB1"; + } + { + std::array const expected = { 0x10CF2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x10CB2, result.begin()); + EXPECT_EQ(result, expected) << 0x10CB2 << " 0x10CB2"; + } + { + std::array const expected = { 0x118C0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118A0, result.begin()); + EXPECT_EQ(result, expected) << 0x118A0 << " 0x118A0"; + } + { + std::array const expected = { 0x118C1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118A1, result.begin()); + EXPECT_EQ(result, expected) << 0x118A1 << " 0x118A1"; + } + { + std::array const expected = { 0x118C2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118A2, result.begin()); + EXPECT_EQ(result, expected) << 0x118A2 << " 0x118A2"; + } + { + std::array const expected = { 0x118C3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118A3, result.begin()); + EXPECT_EQ(result, expected) << 0x118A3 << " 0x118A3"; + } + { + std::array const expected = { 0x118C4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118A4, result.begin()); + EXPECT_EQ(result, expected) << 0x118A4 << " 0x118A4"; + } + { + std::array const expected = { 0x118C5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118A5, result.begin()); + EXPECT_EQ(result, expected) << 0x118A5 << " 0x118A5"; + } + { + std::array const expected = { 0x118C6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118A6, result.begin()); + EXPECT_EQ(result, expected) << 0x118A6 << " 0x118A6"; + } + { + std::array const expected = { 0x118C7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118A7, result.begin()); + EXPECT_EQ(result, expected) << 0x118A7 << " 0x118A7"; + } + { + std::array const expected = { 0x118C8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118A8, result.begin()); + EXPECT_EQ(result, expected) << 0x118A8 << " 0x118A8"; + } + { + std::array const expected = { 0x118C9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118A9, result.begin()); + EXPECT_EQ(result, expected) << 0x118A9 << " 0x118A9"; + } + { + std::array const expected = { 0x118CA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118AA, result.begin()); + EXPECT_EQ(result, expected) << 0x118AA << " 0x118AA"; + } + { + std::array const expected = { 0x118CB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118AB, result.begin()); + EXPECT_EQ(result, expected) << 0x118AB << " 0x118AB"; + } + { + std::array const expected = { 0x118CC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118AC, result.begin()); + EXPECT_EQ(result, expected) << 0x118AC << " 0x118AC"; + } + { + std::array const expected = { 0x118CD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118AD, result.begin()); + EXPECT_EQ(result, expected) << 0x118AD << " 0x118AD"; + } + { + std::array const expected = { 0x118CE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118AE, result.begin()); + EXPECT_EQ(result, expected) << 0x118AE << " 0x118AE"; + } + { + std::array const expected = { 0x118CF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118AF, result.begin()); + EXPECT_EQ(result, expected) << 0x118AF << " 0x118AF"; + } + { + std::array const expected = { 0x118D0, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118B0, result.begin()); + EXPECT_EQ(result, expected) << 0x118B0 << " 0x118B0"; + } +} + +TEST(case_folding, test_29) { + { + std::array const expected = { 0x118D1, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118B1, result.begin()); + EXPECT_EQ(result, expected) << 0x118B1 << " 0x118B1"; + } + { + std::array const expected = { 0x118D2, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118B2, result.begin()); + EXPECT_EQ(result, expected) << 0x118B2 << " 0x118B2"; + } + { + std::array const expected = { 0x118D3, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118B3, result.begin()); + EXPECT_EQ(result, expected) << 0x118B3 << " 0x118B3"; + } + { + std::array const expected = { 0x118D4, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118B4, result.begin()); + EXPECT_EQ(result, expected) << 0x118B4 << " 0x118B4"; + } + { + std::array const expected = { 0x118D5, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118B5, result.begin()); + EXPECT_EQ(result, expected) << 0x118B5 << " 0x118B5"; + } + { + std::array const expected = { 0x118D6, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118B6, result.begin()); + EXPECT_EQ(result, expected) << 0x118B6 << " 0x118B6"; + } + { + std::array const expected = { 0x118D7, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118B7, result.begin()); + EXPECT_EQ(result, expected) << 0x118B7 << " 0x118B7"; + } + { + std::array const expected = { 0x118D8, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118B8, result.begin()); + EXPECT_EQ(result, expected) << 0x118B8 << " 0x118B8"; + } + { + std::array const expected = { 0x118D9, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118B9, result.begin()); + EXPECT_EQ(result, expected) << 0x118B9 << " 0x118B9"; + } + { + std::array const expected = { 0x118DA, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118BA, result.begin()); + EXPECT_EQ(result, expected) << 0x118BA << " 0x118BA"; + } + { + std::array const expected = { 0x118DB, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118BB, result.begin()); + EXPECT_EQ(result, expected) << 0x118BB << " 0x118BB"; + } + { + std::array const expected = { 0x118DC, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118BC, result.begin()); + EXPECT_EQ(result, expected) << 0x118BC << " 0x118BC"; + } + { + std::array const expected = { 0x118DD, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118BD, result.begin()); + EXPECT_EQ(result, expected) << 0x118BD << " 0x118BD"; + } + { + std::array const expected = { 0x118DE, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118BE, result.begin()); + EXPECT_EQ(result, expected) << 0x118BE << " 0x118BE"; + } + { + std::array const expected = { 0x118DF, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x118BF, result.begin()); + EXPECT_EQ(result, expected) << 0x118BF << " 0x118BF"; + } + { + std::array const expected = { 0x16E60, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E40, result.begin()); + EXPECT_EQ(result, expected) << 0x16E40 << " 0x16E40"; + } + { + std::array const expected = { 0x16E61, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E41, result.begin()); + EXPECT_EQ(result, expected) << 0x16E41 << " 0x16E41"; + } + { + std::array const expected = { 0x16E62, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E42, result.begin()); + EXPECT_EQ(result, expected) << 0x16E42 << " 0x16E42"; + } + { + std::array const expected = { 0x16E63, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E43, result.begin()); + EXPECT_EQ(result, expected) << 0x16E43 << " 0x16E43"; + } + { + std::array const expected = { 0x16E64, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E44, result.begin()); + EXPECT_EQ(result, expected) << 0x16E44 << " 0x16E44"; + } + { + std::array const expected = { 0x16E65, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E45, result.begin()); + EXPECT_EQ(result, expected) << 0x16E45 << " 0x16E45"; + } + { + std::array const expected = { 0x16E66, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E46, result.begin()); + EXPECT_EQ(result, expected) << 0x16E46 << " 0x16E46"; + } + { + std::array const expected = { 0x16E67, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E47, result.begin()); + EXPECT_EQ(result, expected) << 0x16E47 << " 0x16E47"; + } + { + std::array const expected = { 0x16E68, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E48, result.begin()); + EXPECT_EQ(result, expected) << 0x16E48 << " 0x16E48"; + } + { + std::array const expected = { 0x16E69, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E49, result.begin()); + EXPECT_EQ(result, expected) << 0x16E49 << " 0x16E49"; + } + { + std::array const expected = { 0x16E6A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E4A, result.begin()); + EXPECT_EQ(result, expected) << 0x16E4A << " 0x16E4A"; + } + { + std::array const expected = { 0x16E6B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E4B, result.begin()); + EXPECT_EQ(result, expected) << 0x16E4B << " 0x16E4B"; + } + { + std::array const expected = { 0x16E6C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E4C, result.begin()); + EXPECT_EQ(result, expected) << 0x16E4C << " 0x16E4C"; + } + { + std::array const expected = { 0x16E6D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E4D, result.begin()); + EXPECT_EQ(result, expected) << 0x16E4D << " 0x16E4D"; + } + { + std::array const expected = { 0x16E6E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E4E, result.begin()); + EXPECT_EQ(result, expected) << 0x16E4E << " 0x16E4E"; + } + { + std::array const expected = { 0x16E6F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E4F, result.begin()); + EXPECT_EQ(result, expected) << 0x16E4F << " 0x16E4F"; + } + { + std::array const expected = { 0x16E70, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E50, result.begin()); + EXPECT_EQ(result, expected) << 0x16E50 << " 0x16E50"; + } + { + std::array const expected = { 0x16E71, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E51, result.begin()); + EXPECT_EQ(result, expected) << 0x16E51 << " 0x16E51"; + } + { + std::array const expected = { 0x16E72, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E52, result.begin()); + EXPECT_EQ(result, expected) << 0x16E52 << " 0x16E52"; + } + { + std::array const expected = { 0x16E73, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E53, result.begin()); + EXPECT_EQ(result, expected) << 0x16E53 << " 0x16E53"; + } + { + std::array const expected = { 0x16E74, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E54, result.begin()); + EXPECT_EQ(result, expected) << 0x16E54 << " 0x16E54"; + } + { + std::array const expected = { 0x16E75, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E55, result.begin()); + EXPECT_EQ(result, expected) << 0x16E55 << " 0x16E55"; + } + { + std::array const expected = { 0x16E76, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E56, result.begin()); + EXPECT_EQ(result, expected) << 0x16E56 << " 0x16E56"; + } + { + std::array const expected = { 0x16E77, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E57, result.begin()); + EXPECT_EQ(result, expected) << 0x16E57 << " 0x16E57"; + } + { + std::array const expected = { 0x16E78, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E58, result.begin()); + EXPECT_EQ(result, expected) << 0x16E58 << " 0x16E58"; + } + { + std::array const expected = { 0x16E79, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E59, result.begin()); + EXPECT_EQ(result, expected) << 0x16E59 << " 0x16E59"; + } + { + std::array const expected = { 0x16E7A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E5A, result.begin()); + EXPECT_EQ(result, expected) << 0x16E5A << " 0x16E5A"; + } + { + std::array const expected = { 0x16E7B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E5B, result.begin()); + EXPECT_EQ(result, expected) << 0x16E5B << " 0x16E5B"; + } + { + std::array const expected = { 0x16E7C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E5C, result.begin()); + EXPECT_EQ(result, expected) << 0x16E5C << " 0x16E5C"; + } + { + std::array const expected = { 0x16E7D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E5D, result.begin()); + EXPECT_EQ(result, expected) << 0x16E5D << " 0x16E5D"; + } + { + std::array const expected = { 0x16E7E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E5E, result.begin()); + EXPECT_EQ(result, expected) << 0x16E5E << " 0x16E5E"; + } + { + std::array const expected = { 0x16E7F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x16E5F, result.begin()); + EXPECT_EQ(result, expected) << 0x16E5F << " 0x16E5F"; + } + { + std::array const expected = { 0x1E922, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E900, result.begin()); + EXPECT_EQ(result, expected) << 0x1E900 << " 0x1E900"; + } + { + std::array const expected = { 0x1E923, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E901, result.begin()); + EXPECT_EQ(result, expected) << 0x1E901 << " 0x1E901"; + } + { + std::array const expected = { 0x1E924, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E902, result.begin()); + EXPECT_EQ(result, expected) << 0x1E902 << " 0x1E902"; + } +} + +TEST(case_folding, test_30) { + { + std::array const expected = { 0x1E925, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E903, result.begin()); + EXPECT_EQ(result, expected) << 0x1E903 << " 0x1E903"; + } + { + std::array const expected = { 0x1E926, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E904, result.begin()); + EXPECT_EQ(result, expected) << 0x1E904 << " 0x1E904"; + } + { + std::array const expected = { 0x1E927, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E905, result.begin()); + EXPECT_EQ(result, expected) << 0x1E905 << " 0x1E905"; + } + { + std::array const expected = { 0x1E928, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E906, result.begin()); + EXPECT_EQ(result, expected) << 0x1E906 << " 0x1E906"; + } + { + std::array const expected = { 0x1E929, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E907, result.begin()); + EXPECT_EQ(result, expected) << 0x1E907 << " 0x1E907"; + } + { + std::array const expected = { 0x1E92A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E908, result.begin()); + EXPECT_EQ(result, expected) << 0x1E908 << " 0x1E908"; + } + { + std::array const expected = { 0x1E92B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E909, result.begin()); + EXPECT_EQ(result, expected) << 0x1E909 << " 0x1E909"; + } + { + std::array const expected = { 0x1E92C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E90A, result.begin()); + EXPECT_EQ(result, expected) << 0x1E90A << " 0x1E90A"; + } + { + std::array const expected = { 0x1E92D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E90B, result.begin()); + EXPECT_EQ(result, expected) << 0x1E90B << " 0x1E90B"; + } + { + std::array const expected = { 0x1E92E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E90C, result.begin()); + EXPECT_EQ(result, expected) << 0x1E90C << " 0x1E90C"; + } + { + std::array const expected = { 0x1E92F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E90D, result.begin()); + EXPECT_EQ(result, expected) << 0x1E90D << " 0x1E90D"; + } + { + std::array const expected = { 0x1E930, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E90E, result.begin()); + EXPECT_EQ(result, expected) << 0x1E90E << " 0x1E90E"; + } + { + std::array const expected = { 0x1E931, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E90F, result.begin()); + EXPECT_EQ(result, expected) << 0x1E90F << " 0x1E90F"; + } + { + std::array const expected = { 0x1E932, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E910, result.begin()); + EXPECT_EQ(result, expected) << 0x1E910 << " 0x1E910"; + } + { + std::array const expected = { 0x1E933, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E911, result.begin()); + EXPECT_EQ(result, expected) << 0x1E911 << " 0x1E911"; + } + { + std::array const expected = { 0x1E934, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E912, result.begin()); + EXPECT_EQ(result, expected) << 0x1E912 << " 0x1E912"; + } + { + std::array const expected = { 0x1E935, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E913, result.begin()); + EXPECT_EQ(result, expected) << 0x1E913 << " 0x1E913"; + } + { + std::array const expected = { 0x1E936, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E914, result.begin()); + EXPECT_EQ(result, expected) << 0x1E914 << " 0x1E914"; + } + { + std::array const expected = { 0x1E937, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E915, result.begin()); + EXPECT_EQ(result, expected) << 0x1E915 << " 0x1E915"; + } + { + std::array const expected = { 0x1E938, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E916, result.begin()); + EXPECT_EQ(result, expected) << 0x1E916 << " 0x1E916"; + } + { + std::array const expected = { 0x1E939, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E917, result.begin()); + EXPECT_EQ(result, expected) << 0x1E917 << " 0x1E917"; + } + { + std::array const expected = { 0x1E93A, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E918, result.begin()); + EXPECT_EQ(result, expected) << 0x1E918 << " 0x1E918"; + } + { + std::array const expected = { 0x1E93B, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E919, result.begin()); + EXPECT_EQ(result, expected) << 0x1E919 << " 0x1E919"; + } + { + std::array const expected = { 0x1E93C, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E91A, result.begin()); + EXPECT_EQ(result, expected) << 0x1E91A << " 0x1E91A"; + } + { + std::array const expected = { 0x1E93D, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E91B, result.begin()); + EXPECT_EQ(result, expected) << 0x1E91B << " 0x1E91B"; + } + { + std::array const expected = { 0x1E93E, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E91C, result.begin()); + EXPECT_EQ(result, expected) << 0x1E91C << " 0x1E91C"; + } + { + std::array const expected = { 0x1E93F, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E91D, result.begin()); + EXPECT_EQ(result, expected) << 0x1E91D << " 0x1E91D"; + } + { + std::array const expected = { 0x1E940, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E91E, result.begin()); + EXPECT_EQ(result, expected) << 0x1E91E << " 0x1E91E"; + } + { + std::array const expected = { 0x1E941, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E91F, result.begin()); + EXPECT_EQ(result, expected) << 0x1E91F << " 0x1E91F"; + } + { + std::array const expected = { 0x1E942, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E920, result.begin()); + EXPECT_EQ(result, expected) << 0x1E920 << " 0x1E920"; + } + { + std::array const expected = { 0x1E943, 0, 0, 0 }; + std::array result = { 0, 0, 0, 0 }; + boost::parser::detail::case_fold(0x1E921, result.begin()); + EXPECT_EQ(result, expected) << 0x1E921 << " 0x1E921"; + } +} + +TEST(case_folding, misses) { + char32_t next_cp = 0; + for (char32_t const * it = cps; it != std::end(cps); ++it) { + for (char32_t cp = next_cp; cp < *it; ++cp) { + std::array const expected = { cp, 0 }; + std::array result = { 0 }; + auto const first = result.data(); + auto const last = boost::parser::detail::case_fold(cp, first); + EXPECT_TRUE(std::equal(first, last, expected.begin())); + EXPECT_EQ(result, expected) << cp; + } + next_cp = *it + 1; + } +}