libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_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 // template <class Elem, unsigned long Maxcode = 0x10ffff,
  12 //           codecvt_mode Mode = (codecvt_mode)0>
  13 // class codecvt_utf8
  14 //     : public codecvt<Elem, char, mbstate_t>
  15 // {
  16 //     // unspecified
  17 // };
  18
  19 // result
  20 //     in(stateT& state,
  21 //        const externT* from, const externT* from_end, const externT*& from_next,
  22 //        internT* to, internT* to_end, internT*& to_next) const;
  23
  24 #include <codecvt>
  25 #include <cassert>
  26
  27 #include "test_macros.h"
  28
  29 int main(int, char**)
  30 {
  31     {
  32         typedef std::codecvt_utf8<char32_t> C;
  33         C c;
  34         char32_t w = 0;
  35         char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
  36         char32_t* wp = nullptr;
  37         std::mbstate_t m;
  38         const char* np = nullptr;
  39         std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
  40         assert(r == std::codecvt_base::ok);
  41         assert(wp == &w+1);
  42         assert(np == n+4);
  43         assert(w == 0x40003);
  44
  45         n[0] = char(0xE1);
  46         n[1] = char(0x80);
  47         n[2] = char(0x85);
  48         r = c.in(m, n, n+3, np, &w, &w+1, wp);
  49         assert(r == std::codecvt_base::ok);
  50         assert(wp == &w+1);
  51         assert(np == n+3);
  52         assert(w == 0x1005);
  53
  54         n[0] = char(0xD1);
  55         n[1] = char(0x93);
  56         r = c.in(m, n, n+2, np, &w, &w+1, wp);
  57         assert(r == std::codecvt_base::ok);
  58         assert(wp == &w+1);
  59         assert(np == n+2);
  60         assert(w == 0x453);
  61
  62         w = 0x56;
  63         n[0] = char(0x56);
  64         r = c.in(m, n, n+1, np, &w, &w+1, wp);
  65         assert(r == std::codecvt_base::ok);
  66         assert(wp == &w+1);
  67         assert(np == n+1);
  68         assert(w == 0x56);
  69     }
  70     {
  71         typedef std::codecvt_utf8<char32_t, 0x1000> C;
  72         C c;
  73         char32_t w = 0;
  74         char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
  75         char32_t* wp = nullptr;
  76         std::mbstate_t m;
  77         const char* np = nullptr;
  78         std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
  79         assert(r == std::codecvt_base::error);
  80         assert(wp == &w);
  81         assert(np == n);
  82         assert(w == 0);
  83
  84         n[0] = char(0xE1);
  85         n[1] = char(0x80);
  86         n[2] = char(0x85);
  87         r = c.in(m, n, n+3, np, &w, &w+1, wp);
  88         assert(r == std::codecvt_base::error);
  89         assert(wp == &w);
  90         assert(np == n);
  91         assert(w == 0);
  92
  93         n[0] = char(0xD1);
  94         n[1] = char(0x93);
  95         r = c.in(m, n, n+2, np, &w, &w+1, wp);
  96         assert(r == std::codecvt_base::ok);
  97         assert(wp == &w+1);
  98         assert(np == n+2);
  99         assert(w == 0x453);
 100
 101         w = 0x56;
 102         n[0] = char(0x56);
 103         r = c.in(m, n, n+1, np, &w, &w+1, wp);
 104         assert(r == std::codecvt_base::ok);
 105         assert(wp == &w+1);
 106         assert(np == n+1);
 107         assert(w == 0x56);
 108     }
 109     {
 110         typedef std::codecvt_utf8<char32_t, 0xFFFFFFFF, std::consume_header> C;
 111         C c;
 112         char32_t w = 0;
 113         char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1), char(0x80), char(0x80), char(0x83)};
 114         char32_t* wp = nullptr;
 115         std::mbstate_t m;
 116         const char* np = nullptr;
 117         std::codecvt_base::result r = c.in(m, n, n+7, np, &w, &w+1, wp);
 118         assert(r == std::codecvt_base::ok);
 119         assert(wp == &w+1);
 120         assert(np == n+7);
 121         assert(w == 0x40003);
 122
 123         n[0] = char(0xE1);
 124         n[1] = char(0x80);
 125         n[2] = char(0x85);
 126         r = c.in(m, n, n+3, np, &w, &w+1, wp);
 127         assert(r == std::codecvt_base::ok);
 128         assert(wp == &w+1);
 129         assert(np == n+3);
 130         assert(w == 0x1005);
 131
 132         n[0] = char(0xEF);
 133         n[1] = char(0xBB);
 134         n[2] = char(0xBF);
 135         n[3] = char(0xD1);
 136         n[4] = char(0x93);
 137         r = c.in(m, n, n+5, np, &w, &w+1, wp);
 138         assert(r == std::codecvt_base::ok);
 139         assert(wp == &w+1);
 140         assert(np == n+5);
 141         assert(w == 0x453);
 142
 143         w = 0x56;
 144         n[0] = char(0x56);
 145         r = c.in(m, n, n+1, np, &w, &w+1, wp);
 146         assert(r == std::codecvt_base::ok);
 147         assert(wp == &w+1);
 148         assert(np == n+1);
 149         assert(w == 0x56);
 150     }
 151     {
 152         typedef std::codecvt_utf8<char32_t> C;
 153         C c;
 154         char32_t w = 0;
 155         char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
 156         char32_t* wp = nullptr;
 157         std::mbstate_t m;
 158         const char* np = nullptr;
 159         std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
 160         assert(r == std::codecvt_base::ok);
 161         assert(wp == &w+1);
 162         assert(np == n+4);
 163         assert(w == 0x40003);
 164
 165         n[0] = char(0xE1);
 166         n[1] = char(0x80);
 167         n[2] = char(0x85);
 168         r = c.in(m, n, n+3, np, &w, &w+1, wp);
 169         assert(r == std::codecvt_base::ok);
 170         assert(wp == &w+1);
 171         assert(np == n+3);
 172         assert(w == 0x1005);
 173
 174         n[0] = char(0xD1);
 175         n[1] = char(0x93);
 176         r = c.in(m, n, n+2, np, &w, &w+1, wp);
 177         assert(r == std::codecvt_base::ok);
 178         assert(wp == &w+1);
 179         assert(np == n+2);
 180         assert(w == 0x453);
 181
 182         w = 0x56;
 183         n[0] = char(0x56);
 184         r = c.in(m, n, n+1, np, &w, &w+1, wp);
 185         assert(r == std::codecvt_base::ok);
 186         assert(wp == &w+1);
 187         assert(np == n+1);
 188         assert(w == 0x56);
 189     }
 190     {
 191         typedef std::codecvt_utf8<char32_t, 0x1000> C;
 192         C c;
 193         char32_t w = 0;
 194         char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
 195         char32_t* wp = nullptr;
 196         std::mbstate_t m;
 197         const char* np = nullptr;
 198         std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
 199         assert(r == std::codecvt_base::error);
 200         assert(wp == &w);
 201         assert(np == n);
 202         assert(w == 0);
 203
 204         n[0] = char(0xE1);
 205         n[1] = char(0x80);
 206         n[2] = char(0x85);
 207         r = c.in(m, n, n+3, np, &w, &w+1, wp);
 208         assert(r == std::codecvt_base::error);
 209         assert(wp == &w);
 210         assert(np == n);
 211         assert(w == 0);
 212
 213         n[0] = char(0xD1);
 214         n[1] = char(0x93);
 215         r = c.in(m, n, n+2, np, &w, &w+1, wp);
 216         assert(r == std::codecvt_base::ok);
 217         assert(wp == &w+1);
 218         assert(np == n+2);
 219         assert(w == 0x453);
 220
 221         w = 0x56;
 222         n[0] = char(0x56);
 223         r = c.in(m, n, n+1, np, &w, &w+1, wp);
 224         assert(r == std::codecvt_base::ok);
 225         assert(wp == &w+1);
 226         assert(np == n+1);
 227         assert(w == 0x56);
 228     }
 229     {
 230         typedef std::codecvt_utf8<char32_t, 0xFFFFFFFF, std::consume_header> C;
 231         C c;
 232         char32_t w = 0;
 233         char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1), char(0x80), char(0x80), char(0x83)};
 234         char32_t* wp = nullptr;
 235         std::mbstate_t m;
 236         const char* np = nullptr;
 237         std::codecvt_base::result r = c.in(m, n, n+7, np, &w, &w+1, wp);
 238         assert(r == std::codecvt_base::ok);
 239         assert(wp == &w+1);
 240         assert(np == n+7);
 241         assert(w == 0x40003);
 242
 243         n[0] = char(0xE1);
 244         n[1] = char(0x80);
 245         n[2] = char(0x85);
 246         r = c.in(m, n, n+3, np, &w, &w+1, wp);
 247         assert(r == std::codecvt_base::ok);
 248         assert(wp == &w+1);
 249         assert(np == n+3);
 250         assert(w == 0x1005);
 251
 252         n[0] = char(0xEF);
 253         n[1] = char(0xBB);
 254         n[2] = char(0xBF);
 255         n[3] = char(0xD1);
 256         n[4] = char(0x93);
 257         r = c.in(m, n, n+5, np, &w, &w+1, wp);
 258         assert(r == std::codecvt_base::ok);
 259         assert(wp == &w+1);
 260         assert(np == n+5);
 261         assert(w == 0x453);
 262
 263         w = 0x56;
 264         n[0] = char(0x56);
 265         r = c.in(m, n, n+1, np, &w, &w+1, wp);
 266         assert(r == std::codecvt_base::ok);
 267         assert(wp == &w+1);
 268         assert(np == n+1);
 269         assert(w == 0x56);
 270     }
 271     {
 272         typedef std::codecvt_utf8<char16_t> C;
 273         C c;
 274         char16_t w = 0;
 275         char n[3] = {char(0xE1), char(0x80), char(0x85)};
 276         char16_t* wp = nullptr;
 277         std::mbstate_t m;
 278         const char* np = nullptr;
 279         std::codecvt_base::result r = c.in(m, n, n+3, np, &w, &w+1, wp);
 280         assert(r == std::codecvt_base::ok);
 281         assert(wp == &w+1);
 282         assert(np == n+3);
 283         assert(w == 0x1005);
 284
 285         n[0] = char(0xD1);
 286         n[1] = char(0x93);
 287         r = c.in(m, n, n+2, np, &w, &w+1, wp);
 288         assert(r == std::codecvt_base::ok);
 289         assert(wp == &w+1);
 290         assert(np == n+2);
 291         assert(w == 0x453);
 292
 293         w = 0x56;
 294         n[0] = char(0x56);
 295         r = c.in(m, n, n+1, np, &w, &w+1, wp);
 296         assert(r == std::codecvt_base::ok);
 297         assert(wp == &w+1);
 298         assert(np == n+1);
 299         assert(w == 0x56);
 300     }
 301     {
 302         typedef std::codecvt_utf8<char16_t, 0x1000> C;
 303         C c;
 304         char16_t w = 0;
 305         char n[3] = {char(0xE1), char(0x80), char(0x85)};
 306         char16_t* wp = nullptr;
 307         std::mbstate_t m;
 308         const char* np = nullptr;
 309         std::codecvt_base::result r = c.in(m, n, n+3, np, &w, &w+1, wp);
 310         assert(r == std::codecvt_base::error);
 311         assert(wp == &w);
 312         assert(np == n);
 313         assert(w == 0);
 314
 315         n[0] = char(0xD1);
 316         n[1] = char(0x93);
 317         r = c.in(m, n, n+2, np, &w, &w+1, wp);
 318         assert(r == std::codecvt_base::ok);
 319         assert(wp == &w+1);
 320         assert(np == n+2);
 321         assert(w == 0x453);
 322
 323         w = 0x56;
 324         n[0] = char(0x56);
 325         r = c.in(m, n, n+1, np, &w, &w+1, wp);
 326         assert(r == std::codecvt_base::ok);
 327         assert(wp == &w+1);
 328         assert(np == n+1);
 329         assert(w == 0x56);
 330     }
 331     {
 332         typedef std::codecvt_utf8<char16_t, 0xFFFFFFFF, std::consume_header> C;
 333         C c;
 334         char16_t w = 0;
 335         char n[6] = {char(0xEF), char(0xBB), char(0xBF), char(0xE1), char(0x80), char(0x85)};
 336         char16_t* wp = nullptr;
 337         std::mbstate_t m;
 338         const char* np = nullptr;
 339         std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp);
 340         assert(r == std::codecvt_base::ok);
 341         assert(wp == &w+1);
 342         assert(np == n+6);
 343         assert(w == 0x1005);
 344
 345         n[0] = char(0xD1);
 346         n[1] = char(0x93);
 347         r = c.in(m, n, n+2, np, &w, &w+1, wp);
 348         assert(r == std::codecvt_base::ok);
 349         assert(wp == &w+1);
 350         assert(np == n+2);
 351         assert(w == 0x453);
 352
 353         w = 0x56;
 354         n[0] = char(0x56);
 355         r = c.in(m, n, n+1, np, &w, &w+1, wp);
 356         assert(r == std::codecvt_base::ok);
 357         assert(wp == &w+1);
 358         assert(np == n+1);
 359         assert(w == 0x56);
 360     }
 361
 362   return 0;
 363 }