1 //===----------------------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 // <codecvt> 11 12 // template <class Elem, unsigned long Maxcode = 0x10ffff, 13 // codecvt_mode Mode = (codecvt_mode)0> 14 // class codecvt_utf16 15 // : public codecvt<Elem, char, mbstate_t> 16 // { 17 // // unspecified 18 // }; 19 20 // result 21 // in(stateT& state, 22 // const externT* from, const externT* from_end, const externT*& from_next, 23 // internT* to, internT* to_end, internT*& to_next) const; 24 25 #include <codecvt> 26 #include <cassert> 27 28 int main() 29 { 30 { 31 typedef std::codecvt_utf16<wchar_t> C; 32 C c; 33 wchar_t w = 0; 34 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)}; 35 wchar_t* wp = nullptr; 36 std::mbstate_t m; 37 const char* np = nullptr; 38 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp); 39 assert(r == std::codecvt_base::ok); 40 assert(wp == &w+1); 41 assert(np == n+4); 42 assert(w == 0x40003); 43 44 n[0] = char(0x10); 45 n[1] = char(0x05); 46 r = c.in(m, n, n+2, np, &w, &w+1, wp); 47 assert(r == std::codecvt_base::ok); 48 assert(wp == &w+1); 49 assert(np == n+2); 50 assert(w == 0x1005); 51 52 n[0] = char(0x04); 53 n[1] = char(0x53); 54 r = c.in(m, n, n+2, np, &w, &w+1, wp); 55 assert(r == std::codecvt_base::ok); 56 assert(wp == &w+1); 57 assert(np == n+2); 58 assert(w == 0x453); 59 60 w = 0x56; 61 n[0] = char(0x00); 62 n[1] = char(0x56); 63 r = c.in(m, n, n+2, np, &w, &w+1, wp); 64 assert(r == std::codecvt_base::ok); 65 assert(wp == &w+1); 66 assert(np == n+2); 67 assert(w == 0x56); 68 } 69 { 70 typedef std::codecvt_utf16<wchar_t, 0x1000> C; 71 C c; 72 wchar_t w = 0; 73 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)}; 74 wchar_t* wp = nullptr; 75 std::mbstate_t m; 76 const char* np = nullptr; 77 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp); 78 assert(r == std::codecvt_base::error); 79 assert(wp == &w); 80 assert(np == n); 81 assert(w == 0); 82 83 n[0] = char(0x10); 84 n[1] = char(0x05); 85 r = c.in(m, n, n+2, np, &w, &w+1, wp); 86 assert(r == std::codecvt_base::error); 87 assert(wp == &w); 88 assert(np == n); 89 assert(w == 0); 90 91 n[0] = char(0x04); 92 n[1] = char(0x53); 93 r = c.in(m, n, n+2, np, &w, &w+1, wp); 94 assert(r == std::codecvt_base::ok); 95 assert(wp == &w+1); 96 assert(np == n+2); 97 assert(w == 0x453); 98 99 w = 0x56; 100 n[0] = char(0x00); 101 n[1] = char(0x56); 102 r = c.in(m, n, n+2, np, &w, &w+1, wp); 103 assert(r == std::codecvt_base::ok); 104 assert(wp == &w+1); 105 assert(np == n+2); 106 assert(w == 0x56); 107 } 108 { 109 typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::consume_header> C; 110 C c; 111 wchar_t w = 0; 112 char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)}; 113 wchar_t* wp = nullptr; 114 std::mbstate_t m; 115 const char* np = nullptr; 116 std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp); 117 assert(r == std::codecvt_base::ok); 118 assert(wp == &w+1); 119 assert(np == n+6); 120 assert(w == 0x40003); 121 122 n[0] = char(0x10); 123 n[1] = char(0x05); 124 r = c.in(m, n, n+2, np, &w, &w+1, wp); 125 assert(r == std::codecvt_base::ok); 126 assert(wp == &w+1); 127 assert(np == n+2); 128 assert(w == 0x1005); 129 130 n[0] = char(0x04); 131 n[1] = char(0x53); 132 r = c.in(m, n, n+2, np, &w, &w+1, wp); 133 assert(r == std::codecvt_base::ok); 134 assert(wp == &w+1); 135 assert(np == n+2); 136 assert(w == 0x453); 137 138 w = 0x56; 139 n[0] = char(0x00); 140 n[1] = char(0x56); 141 r = c.in(m, n, n+2, np, &w, &w+1, wp); 142 assert(r == std::codecvt_base::ok); 143 assert(wp == &w+1); 144 assert(np == n+2); 145 assert(w == 0x56); 146 } 147 { 148 typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::little_endian> C; 149 C c; 150 wchar_t w = 0; 151 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)}; 152 wchar_t* wp = nullptr; 153 std::mbstate_t m; 154 const char* np = nullptr; 155 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp); 156 assert(r == std::codecvt_base::ok); 157 assert(wp == &w+1); 158 assert(np == n+4); 159 assert(w == 0x40003); 160 161 n[1] = char(0x10); 162 n[0] = char(0x05); 163 r = c.in(m, n, n+2, np, &w, &w+1, wp); 164 assert(r == std::codecvt_base::ok); 165 assert(wp == &w+1); 166 assert(np == n+2); 167 assert(w == 0x1005); 168 169 n[1] = char(0x04); 170 n[0] = char(0x53); 171 r = c.in(m, n, n+2, np, &w, &w+1, wp); 172 assert(r == std::codecvt_base::ok); 173 assert(wp == &w+1); 174 assert(np == n+2); 175 assert(w == 0x453); 176 177 w = 0x56; 178 n[1] = char(0x00); 179 n[0] = char(0x56); 180 r = c.in(m, n, n+2, np, &w, &w+1, wp); 181 assert(r == std::codecvt_base::ok); 182 assert(wp == &w+1); 183 assert(np == n+2); 184 assert(w == 0x56); 185 } 186 { 187 typedef std::codecvt_utf16<wchar_t, 0x1000, std::little_endian> C; 188 C c; 189 wchar_t w = 0; 190 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)}; 191 wchar_t* wp = nullptr; 192 std::mbstate_t m; 193 const char* np = nullptr; 194 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp); 195 assert(r == std::codecvt_base::error); 196 assert(wp == &w); 197 assert(np == n); 198 assert(w == 0); 199 200 n[1] = char(0x10); 201 n[0] = char(0x05); 202 r = c.in(m, n, n+2, np, &w, &w+1, wp); 203 assert(r == std::codecvt_base::error); 204 assert(wp == &w); 205 assert(np == n); 206 assert(w == 0); 207 208 n[1] = char(0x04); 209 n[0] = char(0x53); 210 r = c.in(m, n, n+2, np, &w, &w+1, wp); 211 assert(r == std::codecvt_base::ok); 212 assert(wp == &w+1); 213 assert(np == n+2); 214 assert(w == 0x453); 215 216 w = 0x56; 217 n[1] = char(0x00); 218 n[0] = char(0x56); 219 r = c.in(m, n, n+2, np, &w, &w+1, wp); 220 assert(r == std::codecvt_base::ok); 221 assert(wp == &w+1); 222 assert(np == n+2); 223 assert(w == 0x56); 224 } 225 { 226 typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::codecvt_mode( 227 std::consume_header | 228 std::little_endian)> C; 229 C c; 230 wchar_t w = 0; 231 char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)}; 232 wchar_t* wp = nullptr; 233 std::mbstate_t m; 234 const char* np = nullptr; 235 std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp); 236 assert(r == std::codecvt_base::ok); 237 assert(wp == &w+1); 238 assert(np == n+6); 239 assert(w == 0x40003); 240 241 n[1] = char(0x10); 242 n[0] = char(0x05); 243 r = c.in(m, n, n+2, np, &w, &w+1, wp); 244 assert(r == std::codecvt_base::ok); 245 assert(wp == &w+1); 246 assert(np == n+2); 247 assert(w == 0x1005); 248 249 n[1] = char(0x04); 250 n[0] = char(0x53); 251 r = c.in(m, n, n+2, np, &w, &w+1, wp); 252 assert(r == std::codecvt_base::ok); 253 assert(wp == &w+1); 254 assert(np == n+2); 255 assert(w == 0x453); 256 257 w = 0x56; 258 n[1] = char(0x00); 259 n[0] = char(0x56); 260 r = c.in(m, n, n+2, np, &w, &w+1, wp); 261 assert(r == std::codecvt_base::ok); 262 assert(wp == &w+1); 263 assert(np == n+2); 264 assert(w == 0x56); 265 } 266 { 267 typedef std::codecvt_utf16<char32_t> C; 268 C c; 269 char32_t w = 0; 270 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)}; 271 char32_t* wp = nullptr; 272 std::mbstate_t m; 273 const char* np = nullptr; 274 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp); 275 assert(r == std::codecvt_base::ok); 276 assert(wp == &w+1); 277 assert(np == n+4); 278 assert(w == 0x40003); 279 280 n[0] = char(0x10); 281 n[1] = char(0x05); 282 r = c.in(m, n, n+2, np, &w, &w+1, wp); 283 assert(r == std::codecvt_base::ok); 284 assert(wp == &w+1); 285 assert(np == n+2); 286 assert(w == 0x1005); 287 288 n[0] = char(0x04); 289 n[1] = char(0x53); 290 r = c.in(m, n, n+2, np, &w, &w+1, wp); 291 assert(r == std::codecvt_base::ok); 292 assert(wp == &w+1); 293 assert(np == n+2); 294 assert(w == 0x453); 295 296 w = 0x56; 297 n[0] = char(0x00); 298 n[1] = char(0x56); 299 r = c.in(m, n, n+2, np, &w, &w+1, wp); 300 assert(r == std::codecvt_base::ok); 301 assert(wp == &w+1); 302 assert(np == n+2); 303 assert(w == 0x56); 304 } 305 { 306 typedef std::codecvt_utf16<char32_t, 0x1000> C; 307 C c; 308 char32_t w = 0; 309 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)}; 310 char32_t* wp = nullptr; 311 std::mbstate_t m; 312 const char* np = nullptr; 313 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp); 314 assert(r == std::codecvt_base::error); 315 assert(wp == &w); 316 assert(np == n); 317 assert(w == 0); 318 319 n[0] = char(0x10); 320 n[1] = char(0x05); 321 r = c.in(m, n, n+2, np, &w, &w+1, wp); 322 assert(r == std::codecvt_base::error); 323 assert(wp == &w); 324 assert(np == n); 325 assert(w == 0); 326 327 n[0] = char(0x04); 328 n[1] = char(0x53); 329 r = c.in(m, n, n+2, np, &w, &w+1, wp); 330 assert(r == std::codecvt_base::ok); 331 assert(wp == &w+1); 332 assert(np == n+2); 333 assert(w == 0x453); 334 335 w = 0x56; 336 n[0] = char(0x00); 337 n[1] = char(0x56); 338 r = c.in(m, n, n+2, np, &w, &w+1, wp); 339 assert(r == std::codecvt_base::ok); 340 assert(wp == &w+1); 341 assert(np == n+2); 342 assert(w == 0x56); 343 } 344 { 345 typedef std::codecvt_utf16<char32_t, 0x10ffff, std::consume_header> C; 346 C c; 347 char32_t w = 0; 348 char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)}; 349 char32_t* wp = nullptr; 350 std::mbstate_t m; 351 const char* np = nullptr; 352 std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp); 353 assert(r == std::codecvt_base::ok); 354 assert(wp == &w+1); 355 assert(np == n+6); 356 assert(w == 0x40003); 357 358 n[0] = char(0x10); 359 n[1] = char(0x05); 360 r = c.in(m, n, n+2, np, &w, &w+1, wp); 361 assert(r == std::codecvt_base::ok); 362 assert(wp == &w+1); 363 assert(np == n+2); 364 assert(w == 0x1005); 365 366 n[0] = char(0x04); 367 n[1] = char(0x53); 368 r = c.in(m, n, n+2, np, &w, &w+1, wp); 369 assert(r == std::codecvt_base::ok); 370 assert(wp == &w+1); 371 assert(np == n+2); 372 assert(w == 0x453); 373 374 w = 0x56; 375 n[0] = char(0x00); 376 n[1] = char(0x56); 377 r = c.in(m, n, n+2, np, &w, &w+1, wp); 378 assert(r == std::codecvt_base::ok); 379 assert(wp == &w+1); 380 assert(np == n+2); 381 assert(w == 0x56); 382 } 383 { 384 typedef std::codecvt_utf16<char32_t, 0x10ffff, std::little_endian> C; 385 C c; 386 char32_t w = 0; 387 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)}; 388 char32_t* wp = nullptr; 389 std::mbstate_t m; 390 const char* np = nullptr; 391 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp); 392 assert(r == std::codecvt_base::ok); 393 assert(wp == &w+1); 394 assert(np == n+4); 395 assert(w == 0x40003); 396 397 n[1] = char(0x10); 398 n[0] = char(0x05); 399 r = c.in(m, n, n+2, np, &w, &w+1, wp); 400 assert(r == std::codecvt_base::ok); 401 assert(wp == &w+1); 402 assert(np == n+2); 403 assert(w == 0x1005); 404 405 n[1] = char(0x04); 406 n[0] = char(0x53); 407 r = c.in(m, n, n+2, np, &w, &w+1, wp); 408 assert(r == std::codecvt_base::ok); 409 assert(wp == &w+1); 410 assert(np == n+2); 411 assert(w == 0x453); 412 413 w = 0x56; 414 n[1] = char(0x00); 415 n[0] = char(0x56); 416 r = c.in(m, n, n+2, np, &w, &w+1, wp); 417 assert(r == std::codecvt_base::ok); 418 assert(wp == &w+1); 419 assert(np == n+2); 420 assert(w == 0x56); 421 } 422 { 423 typedef std::codecvt_utf16<char32_t, 0x1000, std::little_endian> C; 424 C c; 425 char32_t w = 0; 426 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)}; 427 char32_t* wp = nullptr; 428 std::mbstate_t m; 429 const char* np = nullptr; 430 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp); 431 assert(r == std::codecvt_base::error); 432 assert(wp == &w); 433 assert(np == n); 434 assert(w == 0); 435 436 n[1] = char(0x10); 437 n[0] = char(0x05); 438 r = c.in(m, n, n+2, np, &w, &w+1, wp); 439 assert(r == std::codecvt_base::error); 440 assert(wp == &w); 441 assert(np == n); 442 assert(w == 0); 443 444 n[1] = char(0x04); 445 n[0] = char(0x53); 446 r = c.in(m, n, n+2, np, &w, &w+1, wp); 447 assert(r == std::codecvt_base::ok); 448 assert(wp == &w+1); 449 assert(np == n+2); 450 assert(w == 0x453); 451 452 w = 0x56; 453 n[1] = char(0x00); 454 n[0] = char(0x56); 455 r = c.in(m, n, n+2, np, &w, &w+1, wp); 456 assert(r == std::codecvt_base::ok); 457 assert(wp == &w+1); 458 assert(np == n+2); 459 assert(w == 0x56); 460 } 461 { 462 typedef std::codecvt_utf16<char32_t, 0x10ffff, std::codecvt_mode( 463 std::consume_header | 464 std::little_endian)> C; 465 C c; 466 char32_t w = 0; 467 char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)}; 468 char32_t* wp = nullptr; 469 std::mbstate_t m; 470 const char* np = nullptr; 471 std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp); 472 assert(r == std::codecvt_base::ok); 473 assert(wp == &w+1); 474 assert(np == n+6); 475 assert(w == 0x40003); 476 477 n[1] = char(0x10); 478 n[0] = char(0x05); 479 r = c.in(m, n, n+2, np, &w, &w+1, wp); 480 assert(r == std::codecvt_base::ok); 481 assert(wp == &w+1); 482 assert(np == n+2); 483 assert(w == 0x1005); 484 485 n[1] = char(0x04); 486 n[0] = char(0x53); 487 r = c.in(m, n, n+2, np, &w, &w+1, wp); 488 assert(r == std::codecvt_base::ok); 489 assert(wp == &w+1); 490 assert(np == n+2); 491 assert(w == 0x453); 492 493 w = 0x56; 494 n[1] = char(0x00); 495 n[0] = char(0x56); 496 r = c.in(m, n, n+2, np, &w, &w+1, wp); 497 assert(r == std::codecvt_base::ok); 498 assert(wp == &w+1); 499 assert(np == n+2); 500 assert(w == 0x56); 501 } 502 503 { 504 typedef std::codecvt_utf16<char16_t> C; 505 C c; 506 char16_t w = 0; 507 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)}; 508 char16_t* wp = nullptr; 509 std::mbstate_t m; 510 const char* np = nullptr; 511 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp); 512 assert(r == std::codecvt_base::error); 513 assert(wp == &w); 514 assert(np == n); 515 assert(w == 0); 516 517 n[0] = char(0x10); 518 n[1] = char(0x05); 519 r = c.in(m, n, n+2, np, &w, &w+1, wp); 520 assert(r == std::codecvt_base::ok); 521 assert(wp == &w+1); 522 assert(np == n+2); 523 assert(w == 0x1005); 524 525 n[0] = char(0x04); 526 n[1] = char(0x53); 527 r = c.in(m, n, n+2, np, &w, &w+1, wp); 528 assert(r == std::codecvt_base::ok); 529 assert(wp == &w+1); 530 assert(np == n+2); 531 assert(w == 0x453); 532 533 w = 0x56; 534 n[0] = char(0x00); 535 n[1] = char(0x56); 536 r = c.in(m, n, n+2, np, &w, &w+1, wp); 537 assert(r == std::codecvt_base::ok); 538 assert(wp == &w+1); 539 assert(np == n+2); 540 assert(w == 0x56); 541 } 542 { 543 typedef std::codecvt_utf16<char16_t, 0x1000> C; 544 C c; 545 char16_t w = 0; 546 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)}; 547 char16_t* wp = nullptr; 548 std::mbstate_t m; 549 const char* np = nullptr; 550 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp); 551 assert(r == std::codecvt_base::error); 552 assert(wp == &w); 553 assert(np == n); 554 assert(w == 0); 555 556 n[0] = char(0x10); 557 n[1] = char(0x05); 558 r = c.in(m, n, n+2, np, &w, &w+1, wp); 559 assert(r == std::codecvt_base::error); 560 assert(wp == &w); 561 assert(np == n); 562 assert(w == 0); 563 564 n[0] = char(0x04); 565 n[1] = char(0x53); 566 r = c.in(m, n, n+2, np, &w, &w+1, wp); 567 assert(r == std::codecvt_base::ok); 568 assert(wp == &w+1); 569 assert(np == n+2); 570 assert(w == 0x453); 571 572 w = 0x56; 573 n[0] = char(0x00); 574 n[1] = char(0x56); 575 r = c.in(m, n, n+2, np, &w, &w+1, wp); 576 assert(r == std::codecvt_base::ok); 577 assert(wp == &w+1); 578 assert(np == n+2); 579 assert(w == 0x56); 580 } 581 { 582 typedef std::codecvt_utf16<char16_t, 0x10ffff, std::consume_header> C; 583 C c; 584 char16_t w = 0; 585 char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)}; 586 char16_t* wp = nullptr; 587 std::mbstate_t m; 588 const char* np = nullptr; 589 std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp); 590 assert(r == std::codecvt_base::error); 591 assert(wp == &w); 592 assert(np == n+2); 593 assert(w == 0); 594 595 n[0] = char(0x10); 596 n[1] = char(0x05); 597 r = c.in(m, n, n+2, np, &w, &w+1, wp); 598 assert(r == std::codecvt_base::ok); 599 assert(wp == &w+1); 600 assert(np == n+2); 601 assert(w == 0x1005); 602 603 n[0] = char(0x04); 604 n[1] = char(0x53); 605 r = c.in(m, n, n+2, np, &w, &w+1, wp); 606 assert(r == std::codecvt_base::ok); 607 assert(wp == &w+1); 608 assert(np == n+2); 609 assert(w == 0x453); 610 611 w = 0x56; 612 n[0] = char(0x00); 613 n[1] = char(0x56); 614 r = c.in(m, n, n+2, np, &w, &w+1, wp); 615 assert(r == std::codecvt_base::ok); 616 assert(wp == &w+1); 617 assert(np == n+2); 618 assert(w == 0x56); 619 } 620 { 621 typedef std::codecvt_utf16<char16_t, 0x10ffff, std::little_endian> C; 622 C c; 623 char16_t w = 0; 624 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)}; 625 char16_t* wp = nullptr; 626 std::mbstate_t m; 627 const char* np = nullptr; 628 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp); 629 assert(r == std::codecvt_base::error); 630 assert(wp == &w); 631 assert(np == n); 632 assert(w == 0); 633 634 n[1] = char(0x10); 635 n[0] = char(0x05); 636 r = c.in(m, n, n+2, np, &w, &w+1, wp); 637 assert(r == std::codecvt_base::ok); 638 assert(wp == &w+1); 639 assert(np == n+2); 640 assert(w == 0x1005); 641 642 n[1] = char(0x04); 643 n[0] = char(0x53); 644 r = c.in(m, n, n+2, np, &w, &w+1, wp); 645 assert(r == std::codecvt_base::ok); 646 assert(wp == &w+1); 647 assert(np == n+2); 648 assert(w == 0x453); 649 650 w = 0x56; 651 n[1] = char(0x00); 652 n[0] = char(0x56); 653 r = c.in(m, n, n+2, np, &w, &w+1, wp); 654 assert(r == std::codecvt_base::ok); 655 assert(wp == &w+1); 656 assert(np == n+2); 657 assert(w == 0x56); 658 } 659 { 660 typedef std::codecvt_utf16<char16_t, 0x1000, std::little_endian> C; 661 C c; 662 char16_t w = 0; 663 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)}; 664 char16_t* wp = nullptr; 665 std::mbstate_t m; 666 const char* np = nullptr; 667 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp); 668 assert(r == std::codecvt_base::error); 669 assert(wp == &w); 670 assert(np == n); 671 assert(w == 0); 672 673 n[1] = char(0x10); 674 n[0] = char(0x05); 675 r = c.in(m, n, n+2, np, &w, &w+1, wp); 676 assert(r == std::codecvt_base::error); 677 assert(wp == &w); 678 assert(np == n); 679 assert(w == 0); 680 681 n[1] = char(0x04); 682 n[0] = char(0x53); 683 r = c.in(m, n, n+2, np, &w, &w+1, wp); 684 assert(r == std::codecvt_base::ok); 685 assert(wp == &w+1); 686 assert(np == n+2); 687 assert(w == 0x453); 688 689 w = 0x56; 690 n[1] = char(0x00); 691 n[0] = char(0x56); 692 r = c.in(m, n, n+2, np, &w, &w+1, wp); 693 assert(r == std::codecvt_base::ok); 694 assert(wp == &w+1); 695 assert(np == n+2); 696 assert(w == 0x56); 697 } 698 { 699 typedef std::codecvt_utf16<char16_t, 0x10ffff, std::codecvt_mode( 700 std::consume_header | 701 std::little_endian)> C; 702 C c; 703 char16_t w = 0; 704 char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)}; 705 char16_t* wp = nullptr; 706 std::mbstate_t m; 707 const char* np = nullptr; 708 std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp); 709 assert(r == std::codecvt_base::error); 710 assert(wp == &w); 711 assert(np == n+2); 712 assert(w == 0); 713 714 n[1] = char(0x10); 715 n[0] = char(0x05); 716 r = c.in(m, n, n+2, np, &w, &w+1, wp); 717 assert(r == std::codecvt_base::ok); 718 assert(wp == &w+1); 719 assert(np == n+2); 720 assert(w == 0x1005); 721 722 n[1] = char(0x04); 723 n[0] = char(0x53); 724 r = c.in(m, n, n+2, np, &w, &w+1, wp); 725 assert(r == std::codecvt_base::ok); 726 assert(wp == &w+1); 727 assert(np == n+2); 728 assert(w == 0x453); 729 730 w = 0x56; 731 n[1] = char(0x00); 732 n[0] = char(0x56); 733 r = c.in(m, n, n+2, np, &w, &w+1, wp); 734 assert(r == std::codecvt_base::ok); 735 assert(wp == &w+1); 736 assert(np == n+2); 737 assert(w == 0x56); 738 } 739 } 740
