libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_in.pass.cpp

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