tests/test-mbrtowc-w32.c

   1 /* Test of conversion of multibyte character to wide character.
   2    Copyright (C) 2008-2018 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 #include <config.h>
  18
  19 #include <wchar.h>
  20
  21 #include <errno.h>
  22 #include <locale.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include "macros.h"
  28
  29 #if defined _WIN32 && !defined __CYGWIN__
  30
  31 static int
  32 test_one_locale (const char *name, int codepage)
  33 {
  34   mbstate_t state;
  35   wchar_t wc;
  36   size_t ret;
  37
  38 # if 1
  39   /* Portable code to set the locale.  */
  40   {
  41     char name_with_codepage[1024];
  42
  43     sprintf (name_with_codepage, "%s.%d", name, codepage);
  44
  45     /* Set the locale.  */
  46     if (setlocale (LC_ALL, name_with_codepage) == NULL)
  47       return 77;
  48   }
  49 # else
  50   /* Hacky way to set a locale.codepage combination that setlocale() refuses
  51      to set.  */
  52   {
  53     /* Codepage of the current locale, set with setlocale().
  54        Not necessarily the same as GetACP().  */
  55     extern __declspec(dllimport) unsigned int __lc_codepage;
  56
  57     /* Set the locale.  */
  58     if (setlocale (LC_ALL, name) == NULL)
  59       return 77;
  60
  61     /* Clobber the codepage and MB_CUR_MAX, both set by setlocale().  */
  62     __lc_codepage = codepage;
  63     switch (codepage)
  64       {
  65       case 1252:
  66       case 1256:
  67         MB_CUR_MAX = 1;
  68         break;
  69       case 932:
  70       case 950:
  71       case 936:
  72         MB_CUR_MAX = 2;
  73         break;
  74       case 54936:
  75       case 65001:
  76         MB_CUR_MAX = 4;
  77         break;
  78       }
  79
  80     /* Test whether the codepage is really available.  */
  81     memset (&state, '\0', sizeof (mbstate_t));
  82     if (mbrtowc (&wc, " ", 1, &state) == (size_t)(-1))
  83       return 77;
  84   }
  85 # endif
  86
  87   /* Test zero-length input.  */
  88   {
  89     memset (&state, '\0', sizeof (mbstate_t));
  90     wc = (wchar_t) 0xBADFACE;
  91     ret = mbrtowc (&wc, "x", 0, &state);
  92     /* gnulib's implementation returns (size_t)(-2).
  93        The AIX 5.1 implementation returns (size_t)(-1).
  94        glibc's implementation returns 0.  */
  95     ASSERT (ret == (size_t)(-2) || ret == (size_t)(-1) || ret == 0);
  96     ASSERT (mbsinit (&state));
  97   }
  98
  99   /* Test NUL byte input.  */
 100   {
 101     memset (&state, '\0', sizeof (mbstate_t));
 102     wc = (wchar_t) 0xBADFACE;
 103     ret = mbrtowc (&wc, "", 1, &state);
 104     ASSERT (ret == 0);
 105     ASSERT (wc == 0);
 106     ASSERT (mbsinit (&state));
 107     ret = mbrtowc (NULL, "", 1, &state);
 108     ASSERT (ret == 0);
 109     ASSERT (mbsinit (&state));
 110   }
 111
 112   /* Test single-byte input.  */
 113   {
 114     int c;
 115     char buf[1];
 116
 117     memset (&state, '\0', sizeof (mbstate_t));
 118     for (c = 0; c < 0x100; c++)
 119       switch (c)
 120         {
 121         case '\t': case '\v': case '\f':
 122         case ' ': case '!': case '"': case '#': case '%':
 123         case '&': case '\'': case '(': case ')': case '*':
 124         case '+': case ',': case '-': case '.': case '/':
 125         case '0': case '1': case '2': case '3': case '4':
 126         case '5': case '6': case '7': case '8': case '9':
 127         case ':': case ';': case '<': case '=': case '>':
 128         case '?':
 129         case 'A': case 'B': case 'C': case 'D': case 'E':
 130         case 'F': case 'G': case 'H': case 'I': case 'J':
 131         case 'K': case 'L': case 'M': case 'N': case 'O':
 132         case 'P': case 'Q': case 'R': case 'S': case 'T':
 133         case 'U': case 'V': case 'W': case 'X': case 'Y':
 134         case 'Z':
 135         case '[': case '\\': case ']': case '^': case '_':
 136         case 'a': case 'b': case 'c': case 'd': case 'e':
 137         case 'f': case 'g': case 'h': case 'i': case 'j':
 138         case 'k': case 'l': case 'm': case 'n': case 'o':
 139         case 'p': case 'q': case 'r': case 's': case 't':
 140         case 'u': case 'v': case 'w': case 'x': case 'y':
 141         case 'z': case '{': case '|': case '}': case '~':
 142           /* c is in the ISO C "basic character set".  */
 143           buf[0] = c;
 144           wc = (wchar_t) 0xBADFACE;
 145           ret = mbrtowc (&wc, buf, 1, &state);
 146           ASSERT (ret == 1);
 147           ASSERT (wc == c);
 148           ASSERT (mbsinit (&state));
 149           ret = mbrtowc (NULL, buf, 1, &state);
 150           ASSERT (ret == 1);
 151           ASSERT (mbsinit (&state));
 152           break;
 153         }
 154   }
 155
 156   /* Test special calling convention, passing a NULL pointer.  */
 157   {
 158     memset (&state, '\0', sizeof (mbstate_t));
 159     wc = (wchar_t) 0xBADFACE;
 160     ret = mbrtowc (&wc, NULL, 5, &state);
 161     ASSERT (ret == 0);
 162     ASSERT (wc == (wchar_t) 0xBADFACE);
 163     ASSERT (mbsinit (&state));
 164   }
 165
 166   switch (codepage)
 167     {
 168     case 1252:
 169       /* Locale encoding is CP1252, an extension of ISO-8859-1.  */
 170       {
 171         char input[] = "B\374\337er"; /* "Büßer" */
 172         memset (&state, '\0', sizeof (mbstate_t));
 173
 174         wc = (wchar_t) 0xBADFACE;
 175         ret = mbrtowc (&wc, input, 1, &state);
 176         ASSERT (ret == 1);
 177         ASSERT (wc == 'B');
 178         ASSERT (mbsinit (&state));
 179         input[0] = '\0';
 180
 181         wc = (wchar_t) 0xBADFACE;
 182         ret = mbrtowc (&wc, input + 1, 1, &state);
 183         ASSERT (ret == 1);
 184         ASSERT (wctob (wc) == (unsigned char) '\374');
 185         ASSERT (wc == 0x00FC);
 186         ASSERT (mbsinit (&state));
 187         input[1] = '\0';
 188
 189         /* Test support of NULL first argument.  */
 190         ret = mbrtowc (NULL, input + 2, 3, &state);
 191         ASSERT (ret == 1);
 192         ASSERT (mbsinit (&state));
 193
 194         wc = (wchar_t) 0xBADFACE;
 195         ret = mbrtowc (&wc, input + 2, 3, &state);
 196         ASSERT (ret == 1);
 197         ASSERT (wctob (wc) == (unsigned char) '\337');
 198         ASSERT (wc == 0x00DF);
 199         ASSERT (mbsinit (&state));
 200         input[2] = '\0';
 201
 202         wc = (wchar_t) 0xBADFACE;
 203         ret = mbrtowc (&wc, input + 3, 2, &state);
 204         ASSERT (ret == 1);
 205         ASSERT (wc == 'e');
 206         ASSERT (mbsinit (&state));
 207         input[3] = '\0';
 208
 209         wc = (wchar_t) 0xBADFACE;
 210         ret = mbrtowc (&wc, input + 4, 1, &state);
 211         ASSERT (ret == 1);
 212         ASSERT (wc == 'r');
 213         ASSERT (mbsinit (&state));
 214       }
 215       return 0;
 216
 217     case 1256:
 218       /* Locale encoding is CP1256, not the same as ISO-8859-6.  */
 219       {
 220         char input[] = "x\302\341\346y"; /* "xآلوy" */
 221         memset (&state, '\0', sizeof (mbstate_t));
 222
 223         wc = (wchar_t) 0xBADFACE;
 224         ret = mbrtowc (&wc, input, 1, &state);
 225         ASSERT (ret == 1);
 226         ASSERT (wc == 'x');
 227         ASSERT (mbsinit (&state));
 228         input[0] = '\0';
 229
 230         wc = (wchar_t) 0xBADFACE;
 231         ret = mbrtowc (&wc, input + 1, 1, &state);
 232         ASSERT (ret == 1);
 233         ASSERT (wctob (wc) == (unsigned char) '\302');
 234         ASSERT (wc == 0x0622);
 235         ASSERT (mbsinit (&state));
 236         input[1] = '\0';
 237
 238         /* Test support of NULL first argument.  */
 239         ret = mbrtowc (NULL, input + 2, 3, &state);
 240         ASSERT (ret == 1);
 241         ASSERT (mbsinit (&state));
 242
 243         wc = (wchar_t) 0xBADFACE;
 244         ret = mbrtowc (&wc, input + 2, 3, &state);
 245         ASSERT (ret == 1);
 246         ASSERT (wctob (wc) == (unsigned char) '\341');
 247         ASSERT (wc == 0x0644);
 248         ASSERT (mbsinit (&state));
 249         input[2] = '\0';
 250
 251         wc = (wchar_t) 0xBADFACE;
 252         ret = mbrtowc (&wc, input + 3, 2, &state);
 253         ASSERT (ret == 1);
 254         ASSERT (wctob (wc) == (unsigned char) '\346');
 255         ASSERT (wc == 0x0648);
 256         ASSERT (mbsinit (&state));
 257         input[3] = '\0';
 258
 259         wc = (wchar_t) 0xBADFACE;
 260         ret = mbrtowc (&wc, input + 4, 1, &state);
 261         ASSERT (ret == 1);
 262         ASSERT (wc == 'y');
 263         ASSERT (mbsinit (&state));
 264       }
 265       return 0;
 266
 267     case 932:
 268       /* Locale encoding is CP932, similar to Shift_JIS.  */
 269       {
 270         char input[] = "<\223\372\226\173\214\352>"; /* "<日本語>" */
 271         memset (&state, '\0', sizeof (mbstate_t));
 272
 273         wc = (wchar_t) 0xBADFACE;
 274         ret = mbrtowc (&wc, input, 1, &state);
 275         ASSERT (ret == 1);
 276         ASSERT (wc == '<');
 277         ASSERT (mbsinit (&state));
 278         input[0] = '\0';
 279
 280         wc = (wchar_t) 0xBADFACE;
 281         ret = mbrtowc (&wc, input + 1, 2, &state);
 282         ASSERT (ret == 2);
 283         ASSERT (wctob (wc) == EOF);
 284         ASSERT (wc == 0x65E5);
 285         ASSERT (mbsinit (&state));
 286         input[1] = '\0';
 287         input[2] = '\0';
 288
 289         wc = (wchar_t) 0xBADFACE;
 290         ret = mbrtowc (&wc, input + 3, 1, &state);
 291         ASSERT (ret == (size_t)(-2));
 292         ASSERT (wc == (wchar_t) 0xBADFACE);
 293         ASSERT (!mbsinit (&state));
 294         input[3] = '\0';
 295
 296         wc = (wchar_t) 0xBADFACE;
 297         ret = mbrtowc (&wc, input + 4, 4, &state);
 298         ASSERT (ret == 1);
 299         ASSERT (wctob (wc) == EOF);
 300         ASSERT (wc == 0x672C);
 301         ASSERT (mbsinit (&state));
 302         input[4] = '\0';
 303
 304         /* Test support of NULL first argument.  */
 305         ret = mbrtowc (NULL, input + 5, 3, &state);
 306         ASSERT (ret == 2);
 307         ASSERT (mbsinit (&state));
 308
 309         wc = (wchar_t) 0xBADFACE;
 310         ret = mbrtowc (&wc, input + 5, 3, &state);
 311         ASSERT (ret == 2);
 312         ASSERT (wctob (wc) == EOF);
 313         ASSERT (wc == 0x8A9E);
 314         ASSERT (mbsinit (&state));
 315         input[5] = '\0';
 316         input[6] = '\0';
 317
 318         wc = (wchar_t) 0xBADFACE;
 319         ret = mbrtowc (&wc, input + 7, 1, &state);
 320         ASSERT (ret == 1);
 321         ASSERT (wc == '>');
 322         ASSERT (mbsinit (&state));
 323
 324         /* Test some invalid input.  */
 325         memset (&state, '\0', sizeof (mbstate_t));
 326         wc = (wchar_t) 0xBADFACE;
 327         ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */
 328         ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || ret == (size_t)-2);
 329
 330         memset (&state, '\0', sizeof (mbstate_t));
 331         wc = (wchar_t) 0xBADFACE;
 332         ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */
 333         ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || (ret == 2 && wc == 0x30FB));
 334       }
 335       return 0;
 336
 337     case 950:
 338       /* Locale encoding is CP950, similar to Big5.  */
 339       {
 340         char input[] = "<\244\351\245\273\273\171>"; /* "<日本語>" */
 341         memset (&state, '\0', sizeof (mbstate_t));
 342
 343         wc = (wchar_t) 0xBADFACE;
 344         ret = mbrtowc (&wc, input, 1, &state);
 345         ASSERT (ret == 1);
 346         ASSERT (wc == '<');
 347         ASSERT (mbsinit (&state));
 348         input[0] = '\0';
 349
 350         wc = (wchar_t) 0xBADFACE;
 351         ret = mbrtowc (&wc, input + 1, 2, &state);
 352         ASSERT (ret == 2);
 353         ASSERT (wctob (wc) == EOF);
 354         ASSERT (wc == 0x65E5);
 355         ASSERT (mbsinit (&state));
 356         input[1] = '\0';
 357         input[2] = '\0';
 358
 359         wc = (wchar_t) 0xBADFACE;
 360         ret = mbrtowc (&wc, input + 3, 1, &state);
 361         ASSERT (ret == (size_t)(-2));
 362         ASSERT (wc == (wchar_t) 0xBADFACE);
 363         ASSERT (!mbsinit (&state));
 364         input[3] = '\0';
 365
 366         wc = (wchar_t) 0xBADFACE;
 367         ret = mbrtowc (&wc, input + 4, 4, &state);
 368         ASSERT (ret == 1);
 369         ASSERT (wctob (wc) == EOF);
 370         ASSERT (wc == 0x672C);
 371         ASSERT (mbsinit (&state));
 372         input[4] = '\0';
 373
 374         /* Test support of NULL first argument.  */
 375         ret = mbrtowc (NULL, input + 5, 3, &state);
 376         ASSERT (ret == 2);
 377         ASSERT (mbsinit (&state));
 378
 379         wc = (wchar_t) 0xBADFACE;
 380         ret = mbrtowc (&wc, input + 5, 3, &state);
 381         ASSERT (ret == 2);
 382         ASSERT (wctob (wc) == EOF);
 383         ASSERT (wc == 0x8A9E);
 384         ASSERT (mbsinit (&state));
 385         input[5] = '\0';
 386         input[6] = '\0';
 387
 388         wc = (wchar_t) 0xBADFACE;
 389         ret = mbrtowc (&wc, input + 7, 1, &state);
 390         ASSERT (ret == 1);
 391         ASSERT (wc == '>');
 392         ASSERT (mbsinit (&state));
 393
 394         /* Test some invalid input.  */
 395         memset (&state, '\0', sizeof (mbstate_t));
 396         wc = (wchar_t) 0xBADFACE;
 397         ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */
 398         ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || ret == (size_t)-2);
 399
 400         memset (&state, '\0', sizeof (mbstate_t));
 401         wc = (wchar_t) 0xBADFACE;
 402         ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */
 403         ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || (ret == 2 && wc == '?'));
 404       }
 405       return 0;
 406
 407     case 936:
 408       /* Locale encoding is CP936 = GBK, an extension of GB2312.  */
 409       {
 410         char input[] = "<\310\325\261\276\325\132>"; /* "<日本語>" */
 411         memset (&state, '\0', sizeof (mbstate_t));
 412
 413         wc = (wchar_t) 0xBADFACE;
 414         ret = mbrtowc (&wc, input, 1, &state);
 415         ASSERT (ret == 1);
 416         ASSERT (wc == '<');
 417         ASSERT (mbsinit (&state));
 418         input[0] = '\0';
 419
 420         wc = (wchar_t) 0xBADFACE;
 421         ret = mbrtowc (&wc, input + 1, 2, &state);
 422         ASSERT (ret == 2);
 423         ASSERT (wctob (wc) == EOF);
 424         ASSERT (wc == 0x65E5);
 425         ASSERT (mbsinit (&state));
 426         input[1] = '\0';
 427         input[2] = '\0';
 428
 429         wc = (wchar_t) 0xBADFACE;
 430         ret = mbrtowc (&wc, input + 3, 1, &state);
 431         ASSERT (ret == (size_t)(-2));
 432         ASSERT (wc == (wchar_t) 0xBADFACE);
 433         ASSERT (!mbsinit (&state));
 434         input[3] = '\0';
 435
 436         wc = (wchar_t) 0xBADFACE;
 437         ret = mbrtowc (&wc, input + 4, 4, &state);
 438         ASSERT (ret == 1);
 439         ASSERT (wctob (wc) == EOF);
 440         ASSERT (wc == 0x672C);
 441         ASSERT (mbsinit (&state));
 442         input[4] = '\0';
 443
 444         /* Test support of NULL first argument.  */
 445         ret = mbrtowc (NULL, input + 5, 3, &state);
 446         ASSERT (ret == 2);
 447         ASSERT (mbsinit (&state));
 448
 449         wc = (wchar_t) 0xBADFACE;
 450         ret = mbrtowc (&wc, input + 5, 3, &state);
 451         ASSERT (ret == 2);
 452         ASSERT (wctob (wc) == EOF);
 453         ASSERT (wc == 0x8A9E);
 454         ASSERT (mbsinit (&state));
 455         input[5] = '\0';
 456         input[6] = '\0';
 457
 458         wc = (wchar_t) 0xBADFACE;
 459         ret = mbrtowc (&wc, input + 7, 1, &state);
 460         ASSERT (ret == 1);
 461         ASSERT (wc == '>');
 462         ASSERT (mbsinit (&state));
 463
 464         /* Test some invalid input.  */
 465         memset (&state, '\0', sizeof (mbstate_t));
 466         wc = (wchar_t) 0xBADFACE;
 467         ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */
 468         ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || ret == (size_t)-2);
 469
 470         memset (&state, '\0', sizeof (mbstate_t));
 471         wc = (wchar_t) 0xBADFACE;
 472         ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */
 473         ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || (ret == 2 && wc == '?'));
 474       }
 475       return 0;
 476
 477     case 54936:
 478       /* Locale encoding is CP54936 = GB18030.  */
 479       {
 480         char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */
 481         memset (&state, '\0', sizeof (mbstate_t));
 482
 483         wc = (wchar_t) 0xBADFACE;
 484         ret = mbrtowc (&wc, input, 1, &state);
 485         ASSERT (ret == 1);
 486         ASSERT (wc == 'B');
 487         ASSERT (mbsinit (&state));
 488         input[0] = '\0';
 489
 490         wc = (wchar_t) 0xBADFACE;
 491         ret = mbrtowc (&wc, input + 1, 1, &state);
 492         ASSERT (ret == (size_t)(-2));
 493         ASSERT (wc == (wchar_t) 0xBADFACE);
 494         ASSERT (!mbsinit (&state));
 495         input[1] = '\0';
 496
 497         wc = (wchar_t) 0xBADFACE;
 498         ret = mbrtowc (&wc, input + 2, 7, &state);
 499         ASSERT (ret == 1);
 500         ASSERT (wctob (wc) == EOF);
 501         ASSERT (wc == 0x00FC);
 502         ASSERT (mbsinit (&state));
 503         input[2] = '\0';
 504
 505         /* Test support of NULL first argument.  */
 506         ret = mbrtowc (NULL, input + 3, 6, &state);
 507         ASSERT (ret == 4);
 508         ASSERT (mbsinit (&state));
 509
 510         wc = (wchar_t) 0xBADFACE;
 511         ret = mbrtowc (&wc, input + 3, 6, &state);
 512         ASSERT (ret == 4);
 513         ASSERT (wctob (wc) == EOF);
 514         ASSERT (wc == 0x00DF);
 515         ASSERT (mbsinit (&state));
 516         input[3] = '\0';
 517         input[4] = '\0';
 518         input[5] = '\0';
 519         input[6] = '\0';
 520
 521         wc = (wchar_t) 0xBADFACE;
 522         ret = mbrtowc (&wc, input + 7, 2, &state);
 523         ASSERT (ret == 1);
 524         ASSERT (wc == 'e');
 525         ASSERT (mbsinit (&state));
 526         input[5] = '\0';
 527
 528         wc = (wchar_t) 0xBADFACE;
 529         ret = mbrtowc (&wc, input + 8, 1, &state);
 530         ASSERT (ret == 1);
 531         ASSERT (wc == 'r');
 532         ASSERT (mbsinit (&state));
 533
 534         /* Test some invalid input.  */
 535         memset (&state, '\0', sizeof (mbstate_t));
 536         wc = (wchar_t) 0xBADFACE;
 537         ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */
 538         ASSERT (ret == (size_t)-1);
 539         ASSERT (errno == EILSEQ);
 540
 541         memset (&state, '\0', sizeof (mbstate_t));
 542         wc = (wchar_t) 0xBADFACE;
 543         ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */
 544         ASSERT (ret == (size_t)-1);
 545         ASSERT (errno == EILSEQ);
 546
 547         memset (&state, '\0', sizeof (mbstate_t));
 548         wc = (wchar_t) 0xBADFACE;
 549         ret = mbrtowc (&wc, "\201\045", 2, &state); /* 0x81 0x25 */
 550         ASSERT (ret == (size_t)-1);
 551         ASSERT (errno == EILSEQ);
 552
 553         memset (&state, '\0', sizeof (mbstate_t));
 554         wc = (wchar_t) 0xBADFACE;
 555         ret = mbrtowc (&wc, "\201\060\377", 3, &state); /* 0x81 0x30 0xFF */
 556         ASSERT (ret == (size_t)-1);
 557         ASSERT (errno == EILSEQ);
 558
 559         memset (&state, '\0', sizeof (mbstate_t));
 560         wc = (wchar_t) 0xBADFACE;
 561         ret = mbrtowc (&wc, "\201\060\377\064", 4, &state); /* 0x81 0x30 0xFF 0x34 */
 562         ASSERT (ret == (size_t)-1);
 563         ASSERT (errno == EILSEQ);
 564
 565         memset (&state, '\0', sizeof (mbstate_t));
 566         wc = (wchar_t) 0xBADFACE;
 567         ret = mbrtowc (&wc, "\201\060\211\072", 4, &state); /* 0x81 0x30 0x89 0x3A */
 568         ASSERT (ret == (size_t)-1);
 569         ASSERT (errno == EILSEQ);
 570       }
 571       return 0;
 572
 573     case 65001:
 574       /* Locale encoding is CP65001 = UTF-8.  */
 575       {
 576         char input[] = "B\303\274\303\237er"; /* "Büßer" */
 577         memset (&state, '\0', sizeof (mbstate_t));
 578
 579         wc = (wchar_t) 0xBADFACE;
 580         ret = mbrtowc (&wc, input, 1, &state);
 581         ASSERT (ret == 1);
 582         ASSERT (wc == 'B');
 583         ASSERT (mbsinit (&state));
 584         input[0] = '\0';
 585
 586         wc = (wchar_t) 0xBADFACE;
 587         ret = mbrtowc (&wc, input + 1, 1, &state);
 588         ASSERT (ret == (size_t)(-2));
 589         ASSERT (wc == (wchar_t) 0xBADFACE);
 590         ASSERT (!mbsinit (&state));
 591         input[1] = '\0';
 592
 593         wc = (wchar_t) 0xBADFACE;
 594         ret = mbrtowc (&wc, input + 2, 5, &state);
 595         ASSERT (ret == 1);
 596         ASSERT (wctob (wc) == EOF);
 597         ASSERT (wc == 0x00FC);
 598         ASSERT (mbsinit (&state));
 599         input[2] = '\0';
 600
 601         /* Test support of NULL first argument.  */
 602         ret = mbrtowc (NULL, input + 3, 4, &state);
 603         ASSERT (ret == 2);
 604         ASSERT (mbsinit (&state));
 605
 606         wc = (wchar_t) 0xBADFACE;
 607         ret = mbrtowc (&wc, input + 3, 4, &state);
 608         ASSERT (ret == 2);
 609         ASSERT (wctob (wc) == EOF);
 610         ASSERT (wc == 0x00DF);
 611         ASSERT (mbsinit (&state));
 612         input[3] = '\0';
 613         input[4] = '\0';
 614
 615         wc = (wchar_t) 0xBADFACE;
 616         ret = mbrtowc (&wc, input + 5, 2, &state);
 617         ASSERT (ret == 1);
 618         ASSERT (wc == 'e');
 619         ASSERT (mbsinit (&state));
 620         input[5] = '\0';
 621
 622         wc = (wchar_t) 0xBADFACE;
 623         ret = mbrtowc (&wc, input + 6, 1, &state);
 624         ASSERT (ret == 1);
 625         ASSERT (wc == 'r');
 626         ASSERT (mbsinit (&state));
 627
 628         /* Test some invalid input.  */
 629         memset (&state, '\0', sizeof (mbstate_t));
 630         wc = (wchar_t) 0xBADFACE;
 631         ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */
 632         ASSERT (ret == (size_t)-1);
 633         ASSERT (errno == EILSEQ);
 634
 635         memset (&state, '\0', sizeof (mbstate_t));
 636         wc = (wchar_t) 0xBADFACE;
 637         ret = mbrtowc (&wc, "\303\300", 2, &state); /* 0xC3 0xC0 */
 638         ASSERT (ret == (size_t)-1);
 639         ASSERT (errno == EILSEQ);
 640
 641         memset (&state, '\0', sizeof (mbstate_t));
 642         wc = (wchar_t) 0xBADFACE;
 643         ret = mbrtowc (&wc, "\343\300", 2, &state); /* 0xE3 0xC0 */
 644         ASSERT (ret == (size_t)-1);
 645         ASSERT (errno == EILSEQ);
 646
 647         memset (&state, '\0', sizeof (mbstate_t));
 648         wc = (wchar_t) 0xBADFACE;
 649         ret = mbrtowc (&wc, "\343\300\200", 3, &state); /* 0xE3 0xC0 0x80 */
 650         ASSERT (ret == (size_t)-1);
 651         ASSERT (errno == EILSEQ);
 652
 653         memset (&state, '\0', sizeof (mbstate_t));
 654         wc = (wchar_t) 0xBADFACE;
 655         ret = mbrtowc (&wc, "\343\200\300", 3, &state); /* 0xE3 0x80 0xC0 */
 656         ASSERT (ret == (size_t)-1);
 657         ASSERT (errno == EILSEQ);
 658
 659         memset (&state, '\0', sizeof (mbstate_t));
 660         wc = (wchar_t) 0xBADFACE;
 661         ret = mbrtowc (&wc, "\363\300", 2, &state); /* 0xF3 0xC0 */
 662         ASSERT (ret == (size_t)-1);
 663         ASSERT (errno == EILSEQ);
 664
 665         memset (&state, '\0', sizeof (mbstate_t));
 666         wc = (wchar_t) 0xBADFACE;
 667         ret = mbrtowc (&wc, "\363\300\200\200", 4, &state); /* 0xF3 0xC0 0x80 0x80 */
 668         ASSERT (ret == (size_t)-1);
 669         ASSERT (errno == EILSEQ);
 670
 671         memset (&state, '\0', sizeof (mbstate_t));
 672         wc = (wchar_t) 0xBADFACE;
 673         ret = mbrtowc (&wc, "\363\200\300", 3, &state); /* 0xF3 0x80 0xC0 */
 674         ASSERT (ret == (size_t)-1);
 675         ASSERT (errno == EILSEQ);
 676
 677         memset (&state, '\0', sizeof (mbstate_t));
 678         wc = (wchar_t) 0xBADFACE;
 679         ret = mbrtowc (&wc, "\363\200\300\200", 4, &state); /* 0xF3 0x80 0xC0 0x80 */
 680         ASSERT (ret == (size_t)-1);
 681         ASSERT (errno == EILSEQ);
 682
 683         memset (&state, '\0', sizeof (mbstate_t));
 684         wc = (wchar_t) 0xBADFACE;
 685         ret = mbrtowc (&wc, "\363\200\200\300", 4, &state); /* 0xF3 0x80 0x80 0xC0 */
 686         ASSERT (ret == (size_t)-1);
 687         ASSERT (errno == EILSEQ);
 688       }
 689       return 0;
 690
 691     default:
 692       return 1;
 693     }
 694 }
 695
 696 int
 697 main (int argc, char *argv[])
 698 {
 699   int codepage = atoi (argv[argc - 1]);
 700   int result;
 701   int i;
 702
 703   result = 77;
 704   for (i = 1; i < argc - 1; i++)
 705     {
 706       int ret = test_one_locale (argv[i], codepage);
 707
 708       if (ret != 77)
 709         result = ret;
 710     }
 711
 712   if (result == 77)
 713     {
 714       fprintf (stderr, "Skipping test: found no locale with codepage %d\n",
 715                codepage);
 716     }
 717   return result;
 718 }
 719
 720 #else
 721
 722 int
 723 main (int argc, char *argv[])
 724 {
 725   fputs ("Skipping test: not a native Windows system\n", stderr);
 726   return 77;
 727 }
 728
 729 #endif