1 //===----------------------------------------------------------------------===// 2 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 3 // See https://llvm.org/LICENSE.txt for license information. 4 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 5 // 6 //===----------------------------------------------------------------------===// 7 8 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 9 // UNSUPPORTED: libcpp-has-no-incomplete-format 10 11 // This version runs the test when the platform has Unicode support. 12 // UNSUPPORTED: libcpp-has-no-unicode 13 14 // TODO FMT Investigate Windows and AIX issues. 15 // UNSUPPORTED: msvc, target={{.+}}-windows-gnu 16 // UNSUPPORTED: LIBCXX-AIX-FIXME 17 18 // <format> 19 20 // This test the debug string type for the formatter specializations for char 21 // and string types. This tests Unicode strings. 22 23 #include <format> 24 25 #include <cassert> 26 #include <concepts> 27 #include <iterator> 28 #include <list> 29 #include <vector> 30 31 #include "test_macros.h" 32 #include "make_string.h" 33 #include "test_format_string.h" 34 #include "assert_macros.h" 35 #include "concat_macros.h" 36 37 #ifndef TEST_HAS_NO_LOCALIZATION 38 # include <iostream> 39 #endif 40 41 #define SV(S) MAKE_STRING_VIEW(CharT, S) 42 43 auto test_format = []<class CharT, class... Args>( 44 std::basic_string_view<CharT> expected, test_format_string<CharT, Args...> fmt, Args&&... args) { 45 { 46 std::basic_string<CharT> out = std::format(fmt, std::forward<Args>(args)...); 47 TEST_REQUIRE(out == expected, 48 TEST_WRITE_CONCATENATED( 49 "\nFormat string ", fmt.get(), "\nExpected output ", expected, "\nActual output ", out, '\n')); 50 } 51 #ifndef TEST_HAS_NO_LOCALIZATION 52 { 53 std::basic_string<CharT> out = std::format(std::locale(), fmt, std::forward<Args>(args)...); 54 assert(out == expected); 55 } 56 #endif // TEST_HAS_NO_LOCALIZATION 57 }; 58 59 auto test_format_to = 60 []<class CharT, class... Args>( 61 std::basic_string_view<CharT> expected, test_format_string<CharT, Args...> fmt, Args&&... args) { 62 { 63 std::basic_string<CharT> out(expected.size(), CharT(' ')); 64 auto it = std::format_to(out.begin(), fmt, std::forward<Args>(args)...); 65 assert(it == out.end()); 66 assert(out == expected); 67 } 68 #ifndef TEST_HAS_NO_LOCALIZATION 69 { 70 std::basic_string<CharT> out(expected.size(), CharT(' ')); 71 auto it = std::format_to(out.begin(), std::locale(), fmt, std::forward<Args>(args)...); 72 assert(it == out.end()); 73 assert(out == expected); 74 } 75 #endif // TEST_HAS_NO_LOCALIZATION 76 { 77 std::list<CharT> out; 78 std::format_to(std::back_inserter(out), fmt, std::forward<Args>(args)...); 79 assert(std::equal(out.begin(), out.end(), expected.begin(), expected.end())); 80 } 81 { 82 std::vector<CharT> out; 83 std::format_to(std::back_inserter(out), fmt, std::forward<Args>(args)...); 84 assert(std::equal(out.begin(), out.end(), expected.begin(), expected.end())); 85 } 86 { 87 assert(expected.size() < 4096 && "Update the size of the buffer."); 88 CharT out[4096]; 89 CharT* it = std::format_to(out, fmt, std::forward<Args>(args)...); 90 assert(std::distance(out, it) == int(expected.size())); 91 // Convert to std::string since output contains '\0' for boolean tests. 92 assert(std::basic_string<CharT>(out, it) == expected); 93 } 94 }; 95 96 auto test_formatted_size = 97 []<class CharT, class... Args>( 98 std::basic_string_view<CharT> expected, test_format_string<CharT, Args...> fmt, Args&&... args) { 99 { 100 size_t size = std::formatted_size(fmt, std::forward<Args>(args)...); 101 assert(size == expected.size()); 102 } 103 #ifndef TEST_HAS_NO_LOCALIZATION 104 { 105 size_t size = std::formatted_size(std::locale(), fmt, std::forward<Args>(args)...); 106 assert(size == expected.size()); 107 } 108 #endif // TEST_HAS_NO_LOCALIZATION 109 }; 110 111 auto test_format_to_n = 112 []<class CharT, class... Args>( 113 std::basic_string_view<CharT> expected, test_format_string<CharT, Args...> fmt, Args&&... args) { 114 { 115 size_t n = expected.size(); 116 std::basic_string<CharT> out(n, CharT(' ')); 117 std::format_to_n_result result = std::format_to_n(out.begin(), n, fmt, std::forward<Args>(args)...); 118 assert(result.size == static_cast<ptrdiff_t>(expected.size())); 119 assert(result.out == out.end()); 120 assert(out == expected); 121 } 122 #ifndef TEST_HAS_NO_LOCALIZATION 123 { 124 size_t n = expected.size(); 125 std::basic_string<CharT> out(n, CharT(' ')); 126 std::format_to_n_result result = 127 std::format_to_n(out.begin(), n, std::locale(), fmt, std::forward<Args>(args)...); 128 assert(result.size == static_cast<ptrdiff_t>(expected.size())); 129 assert(result.out == out.end()); 130 assert(out == expected); 131 } 132 #endif // TEST_HAS_NO_LOCALIZATION 133 { 134 ptrdiff_t n = 0; 135 std::basic_string<CharT> out; 136 std::format_to_n_result result = std::format_to_n(out.begin(), n, fmt, std::forward<Args>(args)...); 137 assert(result.size == static_cast<ptrdiff_t>(expected.size())); 138 assert(result.out == out.end()); 139 assert(out.empty()); 140 } 141 { 142 ptrdiff_t n = expected.size() / 2; 143 std::basic_string<CharT> out(n, CharT(' ')); 144 std::format_to_n_result result = std::format_to_n(out.begin(), n, fmt, std::forward<Args>(args)...); 145 assert(result.size == static_cast<ptrdiff_t>(expected.size())); 146 assert(result.out == out.end()); 147 assert(out == expected.substr(0, n)); 148 } 149 }; 150 151 template <class CharT> 152 void test_char() { 153 // *** P2286 examples *** 154 test_format(SV("['\\'', '\"']"), SV("[{:?}, {:?}]"), CharT('\''), CharT('"')); 155 156 // *** Specical cases *** 157 test_format(SV("'\\t'"), SV("{:?}"), CharT('\t')); 158 test_format(SV("'\\n'"), SV("{:?}"), CharT('\n')); 159 test_format(SV("'\\r'"), SV("{:?}"), CharT('\r')); 160 test_format(SV("'\\\\'"), SV("{:?}"), CharT('\\')); 161 162 test_format(SV("'\\\''"), SV("{:?}"), CharT('\'')); 163 test_format(SV("'\"'"), SV("{:?}"), CharT('"')); // only special for string 164 165 test_format(SV("' '"), SV("{:?}"), CharT(' ')); 166 167 // *** Printable *** 168 test_format(SV("'a'"), SV("{:?}"), CharT('a')); 169 test_format(SV("'b'"), SV("{:?}"), CharT('b')); 170 test_format(SV("'c'"), SV("{:?}"), CharT('c')); 171 172 // *** Non-printable *** 173 174 // Control 175 test_format(SV("'\\u{0}'"), SV("{:?}"), CharT('\0')); 176 test_format(SV("'\\u{1f}'"), SV("{:?}"), CharT('\x1f')); 177 178 // Ill-formed 179 if constexpr (sizeof(CharT) == 1) 180 test_format(SV("'\\x{80}'"), SV("{:?}"), CharT('\x80')); 181 182 #ifndef TEST_HAS_NO_WIDE_CHARACTERS 183 if constexpr (sizeof(CharT) > 1) { 184 using V = std::basic_string_view<CharT>; 185 186 // Unicode fitting in a 16-bit wchar_t 187 188 // *** Non-printable *** 189 190 // Space_Separator 191 test_format(V{L"'\\u{a0}'"}, L"{:?}", L'\xa0'); // NO-BREAK SPACE 192 test_format(V{L"'\\u{3000}'"}, L"{:?}", L'\x3000'); // IDEOGRAPHIC SPACE 193 194 // Line_Separator 195 test_format(V{L"'\\u{2028}'"}, L"{:?}", L'\x2028'); // LINE SEPARATOR 196 197 // Paragraph_Separator 198 test_format(V{L"'\\u{2029}'"}, L"{:?}", L'\x2029'); // PARAGRAPH SEPARATOR 199 200 // Format 201 test_format(V{L"'\\u{ad}'"}, L"{:?}", L'\xad'); // SOFT HYPHEN 202 test_format(V{L"'\\u{600}'"}, L"{:?}", L'\x600'); // ARABIC NUMBER SIGN 203 test_format(V{L"'\\u{feff}'"}, L"{:?}", L'\xfeff'); // ZERO WIDTH NO-BREAK SPACE 204 205 // Incomplete surrogate pair in UTF-16 206 test_format(V{L"'\\x{d800}'"}, L"{:?}", L'\xd800'); // <surrogate-D800> 207 test_format(V{L"'\\x{dfff}'"}, L"{:?}", L'\xdfff'); // <surrogate-DFFF> 208 209 // Private_Use 210 test_format(V{L"'\\u{e000}'"}, L"{:?}", L'\xe000'); // <private-use-E000> 211 test_format(V{L"'\\u{f8ff}'"}, L"{:?}", L'\xf8ff'); // <private-use-F8FF> 212 213 // Unassigned 214 test_format(V{L"'\\u{378}'"}, L"{:?}", L'\x378'); // <reserved-0378> 215 test_format(V{L"'\\u{1774}'"}, L"{:?}", L'\x1774'); // <reserved-1774> 216 test_format(V{L"'\\u{ffff}'"}, L"{:?}", L'\xffff'); // <noncharacter-FFFF> 217 218 // Grapheme Extended 219 test_format(V{L"'\\u{300}'"}, L"{:?}", L'\x300'); // COMBINING GRAVE ACCENT 220 test_format(V{L"'\\u{fe20}'"}, L"{:?}", L'\xfe20'); // VARIATION SELECTOR-1 221 } 222 # ifndef TEST_SHORT_WCHAR 223 if constexpr (sizeof(CharT) > 2) { 224 static_assert(sizeof(CharT) == 4, "add support for unexpected size"); 225 // Unicode fitting in a 32-bit wchar_t 226 227 constexpr wchar_t x = 0x1ffff; 228 constexpr std::uint32_t y = 0x1ffff; 229 static_assert(x == y); 230 231 using V = std::basic_string_view<CharT>; 232 233 // *** Non-printable *** 234 // Format 235 test_format(V{L"'\\u{110bd}'"}, L"{:?}", L'\x110bd'); // KAITHI NUMBER SIGN 236 test_format(V{L"'\\u{e007f}'"}, L"{:?}", L'\xe007f'); // CANCEL TAG 237 238 // Private_Use 239 test_format(V{L"'\\u{f0000}'"}, L"{:?}", L'\xf0000'); // <private-use-F0000> 240 test_format(V{L"'\\u{ffffd}'"}, L"{:?}", L'\xffffd'); // <private-use-FFFFD> 241 242 test_format(V{L"'\\u{100000}'"}, L"{:?}", L'\x100000'); // <private-use-100000> 243 test_format(V{L"'\\u{10fffd}'"}, L"{:?}", L'\x10fffd'); // <private-use-10FFFD> 244 245 // Unassigned 246 test_format(V{L"'\\u{1000c}'"}, L"{:?}", L'\x1000c'); // <reserved-1000c> 247 test_format(V{L"'\\u{fffff}'"}, L"{:?}", L'\xfffff'); // <noncharacter-FFFFF> 248 test_format(V{L"'\\u{10fffe}'"}, L"{:?}", L'\x10fffe'); // <noncharacter-10FFFE> 249 250 // Grapheme Extended 251 test_format(V{L"'\\u{101fd}'"}, L"{:?}", L'\x101fd'); // COMBINING OLD PERMIC LETTER AN 252 test_format(V{L"'\\u{e0100}'"}, L"{:?}", L'\xe0100'); // VARIATION SELECTOR-17 253 254 // Ill-formed 255 test_format(V{L"'\\x{110000}'"}, L"{:?}", L'\x110000'); 256 test_format(V{L"'\\x{ffffffff}'"}, L"{:?}", L'\xffffffff'); 257 } 258 # endif // TEST_SHORT_WCHAR 259 #endif // TEST_HAS_NO_WIDE_CHARACTERS 260 } 261 262 template <class CharT> 263 void test_string() { 264 // *** P2286 examples *** 265 test_format(SV("[h\tllo]"), SV("[{}]"), SV("h\tllo")); 266 test_format(SV(R"(["h\tllo"])"), SV("[{:?}]"), SV("h\tllo")); 267 test_format(SV(R"(["Спасибо, Виктор ♥!"])"), SV("[{:?}]"), SV("Спасибо, Виктор ♥!")); 268 269 test_format(SV(R"(["\u{0} \n \t \u{2} \u{1b}"])"), SV("[{:?}]"), SV("\0 \n \t \x02 \x1b")); 270 271 if constexpr (sizeof(CharT) == 1) { 272 // Ill-formend UTF-8 273 test_format(SV(R"(["\x{c3}"])"), SV("[{:?}]"), "\xc3"); 274 test_format(SV(R"(["\x{c3}("])"), SV("[{:?}]"), "\xc3\x28"); 275 276 /* U+0000..U+0007F 1 code unit range, encoded in 2 code units. */ 277 test_format(SV(R"(["\x{c0}\x{80}"])"), SV("[{:?}]"), "\xc0\x80"); // U+0000 278 test_format(SV(R"(["\x{c1}\x{bf}"])"), SV("[{:?}]"), "\xc1\xbf"); // U+007F 279 test_format(SV(R"(["\u{80}"])"), SV("[{:?}]"), "\xc2\x80"); // U+0080 first valid (General_Category=Control) 280 281 /* U+0000..U+07FFF 1 and 2 code unit range, encoded in 3 code units. */ 282 test_format(SV(R"(["\x{e0}\x{80}\x{80}"])"), SV("[{:?}]"), "\xe0\x80\x80"); // U+0000 283 test_format(SV(R"(["\x{e0}\x{81}\x{bf}"])"), SV("[{:?}]"), "\xe0\x81\xbf"); // U+007F 284 test_format(SV(R"(["\x{e0}\x{82}\x{80}"])"), SV("[{:?}]"), "\xe0\x82\x80"); // U+0080 285 test_format(SV(R"(["\x{e0}\x{9f}\x{bf}"])"), SV("[{:?}]"), "\xe0\x9f\xbf"); // U+07FF 286 test_format(SV("[\"\u0800\"]"), SV("[{:?}]"), "\xe0\xa0\x80"); // U+0800 first valid 287 288 #if 0 289 // This code point is in the Hangul Jamo Extended-B block and at the time of writing 290 // it's unassigned. When it comes defined, this branch might become true. 291 test_format(SV("[\"\ud7ff\"]"), SV("[{:?}]"), "\xed\x9f\xbf"); // U+D7FF last valid 292 #else 293 /* U+D800..D+DFFFF surrogate range */ 294 test_format(SV(R"(["\u{d7ff}"])"), SV("[{:?}]"), "\xed\x9f\xbf"); // U+D7FF last valid 295 #endif 296 test_format(SV(R"(["\x{ed}\x{a0}\x{80}"])"), SV("[{:?}]"), "\xed\xa0\x80"); // U+D800 297 test_format(SV(R"(["\x{ed}\x{af}\x{bf}"])"), SV("[{:?}]"), "\xed\xaf\xbf"); // U+DBFF 298 test_format(SV(R"(["\x{ed}\x{bf}\x{80}"])"), SV("[{:?}]"), "\xed\xbf\x80"); // U+DC00 299 test_format(SV(R"(["\x{ed}\x{bf}\x{bf}"])"), SV("[{:?}]"), "\xed\xbf\xbf"); // U+DFFF 300 test_format(SV(R"(["\u{e000}"])"), SV("[{:?}]"), "\xee\x80\x80"); // U+E000 first valid 301 // (in the Private Use Area block) 302 303 /* U+0000..U+FFFF 1, 2, and 3 code unit range */ 304 test_format(SV(R"(["\x{f0}\x{80}\x{80}\x{80}"])"), SV("[{:?}]"), "\xf0\x80\x80\x80"); // U+0000 305 test_format(SV(R"(["\x{f0}\x{80}\x{81}\x{bf}"])"), SV("[{:?}]"), "\xf0\x80\x81\xbf"); // U+007F 306 test_format(SV(R"(["\x{f0}\x{80}\x{82}\x{80}"])"), SV("[{:?}]"), "\xf0\x80\x82\x80"); // U+0080 307 test_format(SV(R"(["\x{f0}\x{80}\x{9f}\x{bf}"])"), SV("[{:?}]"), "\xf0\x80\x9f\xbf"); // U+07FF 308 test_format(SV(R"(["\x{f0}\x{80}\x{a0}\x{80}"])"), SV("[{:?}]"), "\xf0\x80\xa0\x80"); // U+0800 309 test_format(SV(R"(["\x{f0}\x{8f}\x{bf}\x{bf}"])"), SV("[{:?}]"), "\xf0\x8f\xbf\xbf"); // U+FFFF 310 test_format(SV("[\"\U00010000\"]"), SV("[{:?}]"), "\xf0\x90\x80\x80"); // U+10000 first valid 311 312 /* U+10FFFF..U+1FFFFF invalid range */ 313 test_format(SV(R"(["\u{10ffff}"])"), SV("[{:?}]"), "\xf4\x8f\xbf\xbf"); // U+10FFFF last valid 314 // (in Supplementary Private Use Area-B) 315 test_format(SV(R"(["\x{f4}\x{90}\x{80}\x{80}"])"), SV("[{:?}]"), "\xf4\x90\x80\x80"); // U+110000 316 test_format(SV(R"(["\x{f4}\x{bf}\x{bf}\x{bf}"])"), SV("[{:?}]"), "\xf4\xbf\xbf\xbf"); // U+11FFFF 317 } else { 318 // Valid UTF-16 and UTF-32 319 test_format(SV("[\"\u00c3\"]"), SV("[{:?}]"), L"\xc3"); // LATIN CAPITAL LETTER A WITH TILDE 320 test_format(SV("[\"\u00c3(\"]"), SV("[{:?}]"), L"\xc3\x28"); 321 } 322 323 test_format(SV(R"(["\u{200d}♂\u{fe0f}"])"), SV("[{:?}]"), SV("♂️")); 324 325 // *** Specical cases *** 326 test_format(SV(R"("\t\n\r\\'\" ")"), SV("{:?}"), SV("\t\n\r\\'\" ")); 327 328 // *** Printable *** 329 test_format(SV(R"("abcdefg")"), SV("{:?}"), SV("abcdefg")); 330 331 // *** Non-printable *** 332 333 // Control 334 test_format(SV(R"("\u{0}\u{1f}")"), SV("{:?}"), SV("\0\x1f")); 335 336 // Ill-formed 337 if constexpr (sizeof(CharT) == 1) 338 test_format(SV(R"("\x{80}")"), SV("{:?}"), SV("\x80")); 339 340 #ifndef TEST_HAS_NO_WIDE_CHARACTERS 341 if constexpr (sizeof(CharT) > 1) { 342 using V = std::basic_string_view<CharT>; 343 344 // Unicode fitting in a 16-bit wchar_t 345 346 // *** Non-printable *** 347 348 // Space_Separator 349 test_format(V{LR"("\u{a0}\u{3000}")"}, L"{:?}", L"\xa0\x3000"); 350 351 // Line_Separator 352 test_format(V{LR"("\u{2028}")"}, L"{:?}", L"\x2028"); // LINE SEPARATOR 353 354 // Paragraph_Separator 355 test_format(V{LR"("\u{2029}")"}, L"{:?}", L"\x2029"); // PARAGRAPH SEPARATOR 356 357 // Format 358 test_format(V{LR"("\u{ad}\u{600}\u{feff}")"}, L"{:?}", L"\xad\x600\xfeff"); 359 360 // Incomplete surrogate pair in UTF-16 361 test_format(V{LR"("\x{d800}")"}, L"{:?}", L"\xd800"); 362 363 // Private_Use 364 test_format(V{LR"("\u{e000}\u{f8ff}")"}, L"{:?}", L"\xe000\xf8ff"); 365 366 // Unassigned 367 test_format(V{LR"("\u{378}\u{1774}\u{ffff}")"}, L"{:?}", L"\x378\x1774\xffff"); 368 369 // Grapheme Extended 370 test_format(V{LR"("\u{300}\u{fe20}")"}, L"{:?}", L"\x300\xfe20"); 371 } 372 # ifndef TEST_SHORT_WCHAR 373 if constexpr (sizeof(CharT) > 2) { 374 static_assert(sizeof(CharT) == 4, "add support for unexpected size"); 375 // Unicode fitting in a 32-bit wchar_t 376 377 constexpr wchar_t x = 0x1ffff; 378 constexpr std::uint32_t y = 0x1ffff; 379 static_assert(x == y); 380 381 using V = std::basic_string_view<CharT>; 382 383 // *** Non-printable *** 384 // Format 385 test_format(V{LR"("\u{110bd}\u{e007f}")"}, L"{:?}", L"\x110bd\xe007f"); 386 387 // Private_Use 388 test_format(V{LR"("\u{f0000}\u{ffffd}\u{100000}\u{10fffd}")"}, L"{:?}", L"\xf0000\xffffd\x100000\x10fffd"); 389 390 // Unassigned 391 test_format(V{LR"("\u{1000c}\u{fffff}\u{10fffe}")"}, L"{:?}", L"\x1000c\xfffff\x10fffe"); 392 393 // Grapheme Extended 394 test_format(V{LR"("\u{101fd}\u{e0100}")"}, L"{:?}", L"\x101fd\xe0100"); 395 396 // Ill-formed 397 test_format(V{LR"("\x{110000}\x{ffffffff}")"}, L"{:?}", L"\x110000\xffffffff"); 398 } 399 # endif // TEST_SHORT_WCHAR 400 #endif // TEST_HAS_NO_WIDE_CHARACTERS 401 } 402 403 template <class CharT, class TestFunction> 404 void test_format_functions(TestFunction check) { 405 // *** align-fill & width *** 406 check(SV(R"(***"hellö")"), SV("{:*>10?}"), SV("hellö")); // ö is LATIN SMALL LETTER O WITH DIAERESIS 407 check(SV(R"(*"hellö"**)"), SV("{:*^10?}"), SV("hellö")); 408 check(SV(R"("hellö"***)"), SV("{:*<10?}"), SV("hellö")); 409 410 check(SV(R"("hello\u{308}")"), SV("{:*>10?}"), SV("hello\u0308")); 411 check(SV(R"(***"hello\u{308}")"), SV("{:*>17?}"), SV("hello\u0308")); 412 check(SV(R"(*"hello\u{308}"**)"), SV("{:*^17?}"), SV("hello\u0308")); 413 check(SV(R"("hello\u{308}"***)"), SV("{:*<17?}"), SV("hello\u0308")); 414 415 check(SV(R"("hello \u{200d}♂\u{fe0f}")"), SV("{:*>10?}"), SV("hello ♂️")); 416 check(SV(R"(***"hello \u{200d}♂\u{fe0f}")"), SV("{:*>30?}"), SV("hello ♂️")); 417 check(SV(R"(*"hello \u{200d}♂\u{fe0f}"**)"), SV("{:*^30?}"), SV("hello ♂️")); 418 check(SV(R"("hello \u{200d}♂\u{fe0f}"***)"), SV("{:*<30?}"), SV("hello ♂️")); 419 420 // *** width *** 421 check(SV(R"("hellö" )"), SV("{:10?}"), SV("hellö")); 422 check(SV(R"("hello\u{308}" )"), SV("{:17?}"), SV("hello\u0308")); 423 check(SV(R"("hello \u{200d}♂\u{fe0f}" )"), SV("{:30?}"), SV("hello ♂️")); 424 425 // *** precision *** 426 check(SV(R"("hell)"), SV("{:.5?}"), SV("hellö")); 427 check(SV(R"("hellö)"), SV("{:.6?}"), SV("hellö")); 428 check(SV(R"("hellö")"), SV("{:.7?}"), SV("hellö")); 429 430 check(SV(R"("hello )"), SV("{:.7?}"), SV("hello ♂️")); 431 check(SV(R"("hello )"), SV("{:.8?}"), SV("hello ♂️")); // shrug is two columns 432 check(SV(R"("hello )"), SV("{:.9?}"), SV("hello ♂️")); 433 check(SV(R"("hello \)"), SV("{:.10?}"), SV("hello ♂️")); 434 check(SV(R"("hello \u{200d})"), SV("{:.17?}"), SV("hello ♂️")); 435 check(SV(R"("hello \u{200d}♂)"), SV("{:.18?}"), SV("hello ♂️")); 436 check(SV(R"("hello \u{200d}♂\)"), SV("{:.19?}"), SV("hello ♂️")); 437 check(SV(R"("hello \u{200d}♂\u{fe0f}")"), SV("{:.28?}"), SV("hello ♂️")); 438 439 // *** width & precision *** 440 check(SV(R"("hell#########################)"), SV("{:#<30.5?}"), SV("hellö")); 441 check(SV(R"("hellö########################)"), SV("{:#<30.6?}"), SV("hellö")); 442 check(SV(R"("hellö"#######################)"), SV("{:#<30.7?}"), SV("hellö")); 443 444 check(SV(R"("hello #######################)"), SV("{:#<30.7?}"), SV("hello ♂️")); 445 check(SV(R"("hello #######################)"), SV("{:#<30.8?}"), SV("hello ♂️")); 446 check(SV(R"("hello #####################)"), SV("{:#<30.9?}"), SV("hello ♂️")); 447 check(SV(R"("hello \####################)"), SV("{:#<30.10?}"), SV("hello ♂️")); 448 check(SV(R"("hello \u{200d}#############)"), SV("{:#<30.17?}"), SV("hello ♂️")); 449 check(SV(R"("hello \u{200d}♂############)"), SV("{:#<30.18?}"), SV("hello ♂️")); 450 check(SV(R"("hello \u{200d}♂\###########)"), SV("{:#<30.19?}"), SV("hello ♂️")); 451 check(SV(R"("hello \u{200d}♂\u{fe0f}"###)"), SV("{:#<30.28?}"), SV("hello ♂️")); 452 } 453 454 template <class CharT> 455 void test() { 456 test_char<CharT>(); 457 test_string<CharT>(); 458 459 test_format_functions<CharT>(test_format); 460 test_format_functions<CharT>(test_format_to); 461 test_format_functions<CharT>(test_formatted_size); 462 test_format_functions<CharT>(test_format_to_n); 463 } 464 465 static void test_ill_formed_utf8() { 466 using namespace std::literals; 467 468 // Too few code units 469 test_format(R"("\x{df}")"sv, "{:?}", "\xdf"); 470 test_format(R"("\x{ef}")"sv, "{:?}", "\xef"); 471 test_format(R"("\x{ef}\x{bf}")"sv, "{:?}", "\xef\xbf"); 472 test_format(R"("\x{f7}")"sv, "{:?}", "\xf7"); 473 test_format(R"("\x{f7}\x{bf}")"sv, "{:?}", "\xf7\xbf"); 474 test_format(R"("\x{f7}\x{bf}\x{bf}")"sv, "{:?}", "\xf7\xbf\xbf"); 475 476 // Invalid continuation byte 477 test_format(R"("\x{df}a")"sv, 478 "{:?}", 479 "\xdf" 480 "a"); 481 test_format(R"("\x{ef}a")"sv, 482 "{:?}", 483 "\xef" 484 "a"); 485 test_format(R"("\x{ef}\x{bf}a")"sv, 486 "{:?}", 487 "\xef\xbf" 488 "a"); 489 test_format(R"("\x{f7}a")"sv, 490 "{:?}", 491 "\xf7" 492 "a"); 493 test_format(R"("\x{f7}\x{bf}a")"sv, 494 "{:?}", 495 "\xf7\xbf" 496 "a"); 497 test_format(R"("\x{f7}\x{bf}\x{bf}a")"sv, 498 "{:?}", 499 "\xf7\xbf\xbf" 500 "a"); 501 502 // Code unit out of range 503 test_format(R"("\u{10ffff}")"sv, "{:?}", "\xf4\x8f\xbf\xbf"); // last valid code point 504 test_format(R"("\x{f4}\x{90}\x{80}\x{80}")"sv, "{:?}", "\xf4\x90\x80\x80"); // first invalid code point 505 test_format(R"("\x{f5}\x{b1}\x{b2}\x{b3}")"sv, "{:?}", "\xf5\xb1\xb2\xb3"); 506 test_format(R"("\x{f7}\x{bf}\x{bf}\x{bf}")"sv, "{:?}", "\xf7\xbf\xbf\xbf"); // largest encoded code point 507 } 508 509 #ifndef TEST_HAS_NO_WIDE_CHARACTERS 510 # ifdef _LIBCPP_SHORT_WCHAR 511 static void test_ill_formed_utf16() { 512 using namespace std::literals; 513 514 // Too few code units 515 test_format(LR"("\x{d800}")"sv, L"{:?}", L"\xd800"); 516 test_format(LR"("\x{dbff}")"sv, L"{:?}", L"\xdbff"); 517 518 // Start with low surrogate pair 519 test_format(LR"("\x{dc00}a")"sv, 520 L"{:?}", 521 L"\xdc00" 522 "a"); 523 test_format(LR"("\x{dfff}a")"sv, 524 L"{:?}", 525 L"\xdfff" 526 "a"); 527 528 // Only high surrogate pair 529 test_format(LR"("\x{d800}a")"sv, 530 L"{:?}", 531 L"\xd800" 532 "a"); 533 test_format(LR"("\x{dbff}a")"sv, 534 L"{:?}", 535 L"\xdbff" 536 "a"); 537 } 538 # else // _LIBCPP_SHORT_WCHAR 539 static void test_ill_formed_utf32() { 540 using namespace std::literals; 541 542 test_format(LR"("\u{10ffff}")"sv, L"{:?}", L"\x10ffff"); // last valid code point 543 test_format(LR"("\x{110000}")"sv, L"{:?}", L"\x110000"); // first invalid code point 544 test_format(LR"("\x{ffffffff}")"sv, L"{:?}", L"\xffffffff"); // largest encoded code point 545 } 546 547 # endif // _LIBCPP_SHORT_WCHAR 548 #endif // TEST_HAS_NO_WIDE_CHARACTERS 549 550 int main(int, char**) { 551 test<char>(); 552 #ifndef TEST_HAS_NO_WIDE_CHARACTERS 553 test<wchar_t>(); 554 #endif 555 556 test_ill_formed_utf8(); 557 #ifndef TEST_HAS_NO_WIDE_CHARACTERS 558 # ifdef _LIBCPP_SHORT_WCHAR 559 test_ill_formed_utf16(); 560 assert(false); 561 # else // _LIBCPP_SHORT_WCHAR 562 test_ill_formed_utf32(); 563 # endif // _LIBCPP_SHORT_WCHAR 564 #endif // TEST_HAS_NO_WIDE_CHARACTERS 565 566 return 0; 567 } 568