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