libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_length.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 // template <class Elem, unsigned long Maxcode = 0x10ffff,
  12 //           codecvt_mode Mode = (codecvt_mode)0>
  13 // class codecvt_utf16
  14 //     : public codecvt<Elem, char, mbstate_t>
  15 // {
  16 //     // unspecified
  17 // };
  18
  19 // int length(stateT& state, const externT* from, const externT* from_end,
  20 //            size_t max) const;
  21
  22 #include <codecvt>
  23 #include <cassert>
  24
  25 #include "test_macros.h"
  26
  27 int main(int, char**)
  28 {
  29     {
  30         typedef std::codecvt_utf16<wchar_t> C;
  31         C c;
  32         char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
  33         std::mbstate_t m;
  34         int r = c.length(m, n, n+4, 2);
  35         assert(r == 4);
  36
  37         n[0] = char(0x10);
  38         n[1] = char(0x05);
  39         r = c.length(m, n, n+2, 2);
  40         assert(r == 2);
  41
  42         n[0] = char(0x04);
  43         n[1] = char(0x53);
  44         r = c.length(m, n, n+2, 2);
  45         assert(r == 2);
  46
  47         n[0] = char(0x00);
  48         n[1] = char(0x56);
  49         r = c.length(m, n, n+2, 2);
  50         assert(r == 2);
  51     }
  52     {
  53         typedef std::codecvt_utf16<wchar_t, 0x1000> C;
  54         C c;
  55         char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
  56         std::mbstate_t m;
  57         int r = c.length(m, n, n+4, 2);
  58         assert(r == 0);
  59
  60         n[0] = char(0x10);
  61         n[1] = char(0x05);
  62         r = c.length(m, n, n+2, 2);
  63         assert(r == 0);
  64
  65         n[0] = char(0x04);
  66         n[1] = char(0x53);
  67         r = c.length(m, n, n+2, 2);
  68         assert(r == 2);
  69
  70         n[0] = char(0x00);
  71         n[1] = char(0x56);
  72         r = c.length(m, n, n+2, 2);
  73         assert(r == 2);
  74     }
  75     {
  76         typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::consume_header> C;
  77         C c;
  78         char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)};
  79         std::mbstate_t m;
  80         int r = c.length(m, n, n+6, 2);
  81         assert(r == 6);
  82
  83         n[0] = char(0x10);
  84         n[1] = char(0x05);
  85         r = c.length(m, n, n+2, 2);
  86         assert(r == 2);
  87
  88         n[0] = char(0x04);
  89         n[1] = char(0x53);
  90         r = c.length(m, n, n+2, 2);
  91         assert(r == 2);
  92
  93         n[0] = char(0x00);
  94         n[1] = char(0x56);
  95         r = c.length(m, n, n+2, 2);
  96         assert(r == 2);
  97     }
  98     {
  99         typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::little_endian> C;
 100         C c;
 101         char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
 102         std::mbstate_t m;
 103         int r = c.length(m, n, n+4, 2);
 104         assert(r == 4);
 105
 106         n[1] = char(0x10);
 107         n[0] = char(0x05);
 108         r = c.length(m, n, n+2, 2);
 109         assert(r == 2);
 110
 111         n[1] = char(0x04);
 112         n[0] = char(0x53);
 113         r = c.length(m, n, n+2, 2);
 114         assert(r == 2);
 115
 116         n[1] = char(0x00);
 117         n[0] = char(0x56);
 118         r = c.length(m, n, n+2, 2);
 119         assert(r == 2);
 120     }
 121     {
 122         typedef std::codecvt_utf16<wchar_t, 0x1000, std::little_endian> C;
 123         C c;
 124         char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
 125         std::mbstate_t m;
 126         int r = c.length(m, n, n+4, 2);
 127         assert(r == 0);
 128
 129         n[1] = char(0x10);
 130         n[0] = char(0x05);
 131         r = c.length(m, n, n+2, 2);
 132         assert(r == 0);
 133
 134         n[1] = char(0x04);
 135         n[0] = char(0x53);
 136         r = c.length(m, n, n+2, 2);
 137         assert(r == 2);
 138
 139         n[1] = char(0x00);
 140         n[0] = char(0x56);
 141         r = c.length(m, n, n+2, 2);
 142         assert(r == 2);
 143     }
 144     {
 145         typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::codecvt_mode(
 146                                                          std::consume_header |
 147                                                          std::little_endian)> C;
 148         C c;
 149         char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)};
 150         std::mbstate_t m;
 151         int r = c.length(m, n, n+6, 2);
 152         assert(r == 6);
 153
 154         n[1] = char(0x10);
 155         n[0] = char(0x05);
 156         r = c.length(m, n, n+2, 2);
 157         assert(r == 2);
 158
 159         n[1] = char(0x04);
 160         n[0] = char(0x53);
 161         r = c.length(m, n, n+2, 2);
 162         assert(r == 2);
 163
 164         n[1] = char(0x00);
 165         n[0] = char(0x56);
 166         r = c.length(m, n, n+2, 2);
 167         assert(r == 2);
 168     }
 169     {
 170         typedef std::codecvt_utf16<char32_t> C;
 171         C c;
 172         char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
 173         std::mbstate_t m;
 174         int r = c.length(m, n, n+4, 2);
 175         assert(r == 4);
 176
 177         n[0] = char(0x10);
 178         n[1] = char(0x05);
 179         r = c.length(m, n, n+2, 2);
 180         assert(r == 2);
 181
 182         n[0] = char(0x04);
 183         n[1] = char(0x53);
 184         r = c.length(m, n, n+2, 2);
 185         assert(r == 2);
 186
 187         n[0] = char(0x00);
 188         n[1] = char(0x56);
 189         r = c.length(m, n, n+2, 2);
 190         assert(r == 2);
 191     }
 192     {
 193         typedef std::codecvt_utf16<char32_t, 0x1000> C;
 194         C c;
 195         char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
 196         std::mbstate_t m;
 197         int r = c.length(m, n, n+4, 2);
 198         assert(r == 0);
 199
 200         n[0] = char(0x10);
 201         n[1] = char(0x05);
 202         r = c.length(m, n, n+2, 2);
 203         assert(r == 0);
 204
 205         n[0] = char(0x04);
 206         n[1] = char(0x53);
 207         r = c.length(m, n, n+2, 2);
 208         assert(r == 2);
 209
 210         n[0] = char(0x00);
 211         n[1] = char(0x56);
 212         r = c.length(m, n, n+2, 2);
 213         assert(r == 2);
 214     }
 215     {
 216         typedef std::codecvt_utf16<char32_t, 0x10ffff, std::consume_header> C;
 217         C c;
 218         char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)};
 219         std::mbstate_t m;
 220         int r = c.length(m, n, n+6, 2);
 221         assert(r == 6);
 222
 223         n[0] = char(0x10);
 224         n[1] = char(0x05);
 225         r = c.length(m, n, n+2, 2);
 226         assert(r == 2);
 227
 228         n[0] = char(0x04);
 229         n[1] = char(0x53);
 230         r = c.length(m, n, n+2, 2);
 231         assert(r == 2);
 232
 233         n[0] = char(0x00);
 234         n[1] = char(0x56);
 235         r = c.length(m, n, n+2, 2);
 236         assert(r == 2);
 237     }
 238     {
 239         typedef std::codecvt_utf16<char32_t, 0x10ffff, std::little_endian> C;
 240         C c;
 241         char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
 242         std::mbstate_t m;
 243         int r = c.length(m, n, n+4, 2);
 244         assert(r == 4);
 245
 246         n[1] = char(0x10);
 247         n[0] = char(0x05);
 248         r = c.length(m, n, n+2, 2);
 249         assert(r == 2);
 250
 251         n[1] = char(0x04);
 252         n[0] = char(0x53);
 253         r = c.length(m, n, n+2, 2);
 254         assert(r == 2);
 255
 256         n[1] = char(0x00);
 257         n[0] = char(0x56);
 258         r = c.length(m, n, n+2, 2);
 259         assert(r == 2);
 260     }
 261     {
 262         typedef std::codecvt_utf16<char32_t, 0x1000, std::little_endian> C;
 263         C c;
 264         char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
 265         std::mbstate_t m;
 266         int r = c.length(m, n, n+4, 2);
 267         assert(r == 0);
 268
 269         n[1] = char(0x10);
 270         n[0] = char(0x05);
 271         r = c.length(m, n, n+2, 2);
 272         assert(r == 0);
 273
 274         n[1] = char(0x04);
 275         n[0] = char(0x53);
 276         r = c.length(m, n, n+2, 2);
 277         assert(r == 2);
 278
 279         n[1] = char(0x00);
 280         n[0] = char(0x56);
 281         r = c.length(m, n, n+2, 2);
 282         assert(r == 2);
 283     }
 284     {
 285         typedef std::codecvt_utf16<char32_t, 0x10ffff, std::codecvt_mode(
 286                                                          std::consume_header |
 287                                                          std::little_endian)> C;
 288         C c;
 289         char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)};
 290         std::mbstate_t m;
 291         int r = c.length(m, n, n+6, 2);
 292         assert(r == 6);
 293
 294         n[1] = char(0x10);
 295         n[0] = char(0x05);
 296         r = c.length(m, n, n+2, 2);
 297         assert(r == 2);
 298
 299         n[1] = char(0x04);
 300         n[0] = char(0x53);
 301         r = c.length(m, n, n+2, 2);
 302         assert(r == 2);
 303
 304         n[1] = char(0x00);
 305         n[0] = char(0x56);
 306         r = c.length(m, n, n+2, 2);
 307         assert(r == 2);
 308     }
 309
 310     {
 311         typedef std::codecvt_utf16<char16_t> C;
 312         C c;
 313         char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
 314         std::mbstate_t m;
 315         int r = c.length(m, n, n+4, 2);
 316         assert(r == 0);
 317
 318         n[0] = char(0x10);
 319         n[1] = char(0x05);
 320         r = c.length(m, n, n+2, 2);
 321         assert(r == 2);
 322
 323         n[0] = char(0x04);
 324         n[1] = char(0x53);
 325         r = c.length(m, n, n+2, 2);
 326         assert(r == 2);
 327
 328         n[0] = char(0x00);
 329         n[1] = char(0x56);
 330         r = c.length(m, n, n+2, 2);
 331         assert(r == 2);
 332     }
 333     {
 334         typedef std::codecvt_utf16<char16_t, 0x1000> C;
 335         C c;
 336         char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
 337         std::mbstate_t m;
 338         int r = c.length(m, n, n+4, 2);
 339         assert(r == 0);
 340
 341         n[0] = char(0x10);
 342         n[1] = char(0x05);
 343         r = c.length(m, n, n+2, 2);
 344         assert(r == 0);
 345
 346         n[0] = char(0x04);
 347         n[1] = char(0x53);
 348         r = c.length(m, n, n+2, 2);
 349         assert(r == 2);
 350
 351         n[0] = char(0x00);
 352         n[1] = char(0x56);
 353         r = c.length(m, n, n+2, 2);
 354         assert(r == 2);
 355     }
 356     {
 357         typedef std::codecvt_utf16<char16_t, 0x10ffff, std::consume_header> C;
 358         C c;
 359         char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)};
 360         std::mbstate_t m;
 361         int r = c.length(m, n, n+6, 2);
 362         assert(r == 2);
 363
 364         n[0] = char(0x10);
 365         n[1] = char(0x05);
 366         r = c.length(m, n, n+2, 2);
 367         assert(r == 2);
 368
 369         n[0] = char(0x04);
 370         n[1] = char(0x53);
 371         r = c.length(m, n, n+2, 2);
 372         assert(r == 2);
 373
 374         n[0] = char(0x00);
 375         n[1] = char(0x56);
 376         r = c.length(m, n, n+2, 2);
 377         assert(r == 2);
 378     }
 379     {
 380         typedef std::codecvt_utf16<char16_t, 0x10ffff, std::little_endian> C;
 381         C c;
 382         char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
 383         std::mbstate_t m;
 384         int r = c.length(m, n, n+4, 2);
 385         assert(r == 0);
 386
 387         n[1] = char(0x10);
 388         n[0] = char(0x05);
 389         r = c.length(m, n, n+2, 2);
 390         assert(r == 2);
 391
 392         n[1] = char(0x04);
 393         n[0] = char(0x53);
 394         r = c.length(m, n, n+2, 2);
 395         assert(r == 2);
 396
 397         n[1] = char(0x00);
 398         n[0] = char(0x56);
 399         r = c.length(m, n, n+2, 2);
 400         assert(r == 2);
 401     }
 402     {
 403         typedef std::codecvt_utf16<char16_t, 0x1000, std::little_endian> C;
 404         C c;
 405         char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
 406         std::mbstate_t m;
 407         int r = c.length(m, n, n+4, 2);
 408         assert(r == 0);
 409
 410         n[1] = char(0x10);
 411         n[0] = char(0x05);
 412         r = c.length(m, n, n+2, 2);
 413         assert(r == 0);
 414
 415         n[1] = char(0x04);
 416         n[0] = char(0x53);
 417         r = c.length(m, n, n+2, 2);
 418         assert(r == 2);
 419
 420         n[1] = char(0x00);
 421         n[0] = char(0x56);
 422         r = c.length(m, n, n+2, 2);
 423         assert(r == 2);
 424     }
 425     {
 426         typedef std::codecvt_utf16<char16_t, 0x10ffff, std::codecvt_mode(
 427                                                          std::consume_header |
 428                                                          std::little_endian)> C;
 429         C c;
 430         char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)};
 431         std::mbstate_t m;
 432         int r = c.length(m, n, n+6, 2);
 433         assert(r == 2);
 434
 435         n[1] = char(0x10);
 436         n[0] = char(0x05);
 437         r = c.length(m, n, n+2, 2);
 438         assert(r == 2);
 439
 440         n[1] = char(0x04);
 441         n[0] = char(0x53);
 442         r = c.length(m, n, n+2, 2);
 443         assert(r == 2);
 444
 445         n[1] = char(0x00);
 446         n[0] = char(0x56);
 447         r = c.length(m, n, n+2, 2);
 448         assert(r == 2);
 449     }
 450
 451   return 0;
 452 }