git.oblomov.eu Git - wine/blob - dlls/msvcrt/tests/string.c

   1 /*
   2  * Unit test suite for string functions.
   3  *
   4  * Copyright 2004 Uwe Bonnes
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "wine/test.h"
  22 #include "winbase.h"
  23 #include <string.h>
  24 #include <mbstring.h>
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <mbctype.h>
  28 #include <locale.h>
  29 #include <errno.h>
  30
  31 static char *buf_to_string(const unsigned char *bin, int len, int nr)
  32 {
  33     static char buf[2][1024];
  34     char *w = buf[nr];
  35     int i;
  36
  37     for (i = 0; i < len; i++)
  38     {
  39         sprintf(w, "%02x ", (unsigned char)bin[i]);
  40         w += strlen(w);
  41     }
  42     return buf[nr];
  43 }
  44
  45 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
  46 #define expect_bin(buf, value, len) { ok(memcmp((buf), value, len) == 0, "Binary buffer mismatch - expected %s, got %s\n", buf_to_string((unsigned char *)value, len, 1), buf_to_string((buf), len, 0)); }
  47
  48 static void* (__cdecl *pmemcpy)(void *, const void *, size_t n);
  49 static int* (__cdecl *pmemcmp)(void *, const void *, size_t n);
  50 static int (__cdecl *pstrcpy_s)(char *dst, size_t len, const char *src);
  51 static int (__cdecl *pstrcat_s)(char *dst, size_t len, const char *src);
  52 static int (__cdecl *p_mbsnbcpy_s)(unsigned char * dst, size_t size, const unsigned char * src, size_t count);
  53 static int (__cdecl *p_wcscpy_s)(wchar_t *wcDest, size_t size, const wchar_t *wcSrc);
  54 static int (__cdecl *p_wcsupr_s)(wchar_t *str, size_t size);
  55 static int *p__mb_cur_max;
  56 static unsigned char *p_mbctype;
  57
  58 #define SETNOFAIL(x,y) x = (void*)GetProcAddress(hMsvcrt,y)
  59 #define SET(x,y) SETNOFAIL(x,y); ok(x != NULL, "Export '%s' not found\n", y)
  60
  61 HMODULE hMsvcrt;
  62
  63 static void test_swab( void ) {
  64     char original[]  = "BADCFEHGJILKNMPORQTSVUXWZY@#";
  65     char expected1[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ@#";
  66     char expected2[] = "ABCDEFGHIJKLMNOPQRSTUVWX$";
  67     char expected3[] = "$";
  68
  69     char from[30];
  70     char to[30];
  71
  72     int testsize;
  73
  74     /* Test 1 - normal even case */
  75     memset(to,'$', sizeof(to));
  76     memset(from,'@', sizeof(from));
  77     testsize = 26;
  78     memcpy(from, original, testsize);
  79     _swab( from, to, testsize );
  80     ok(memcmp(to,expected1,testsize) == 0, "Testing even size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
  81
  82     /* Test 2 - uneven case  */
  83     memset(to,'$', sizeof(to));
  84     memset(from,'@', sizeof(from));
  85     testsize = 25;
  86     memcpy(from, original, testsize);
  87     _swab( from, to, testsize );
  88     ok(memcmp(to,expected2,testsize) == 0, "Testing odd size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
  89
  90     /* Test 3 - from = to */
  91     memset(to,'$', sizeof(to));
  92     memset(from,'@', sizeof(from));
  93     testsize = 26;
  94     memcpy(to, original, testsize);
  95     _swab( to, to, testsize );
  96     ok(memcmp(to,expected1,testsize) == 0, "Testing overlapped size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
  97
  98     /* Test 4 - 1 bytes */
  99     memset(to,'$', sizeof(to));
 100     memset(from,'@', sizeof(from));
 101     testsize = 1;
 102     memcpy(from, original, testsize);
 103     _swab( from, to, testsize );
 104     ok(memcmp(to,expected3,testsize) == 0, "Testing small size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
 105 }
 106
 107 #if 0      /* use this to generate more tests */
 108
 109 static void test_codepage(int cp)
 110 {
 111     int i;
 112     int prev;
 113     int count = 1;
 114
 115     ok(_setmbcp(cp) == 0, "Couldn't set mbcp\n");
 116
 117     prev = p_mbctype[0];
 118     printf("static int result_cp_%d_mbctype[] = { ", cp);
 119     for (i = 1; i < 257; i++)
 120     {
 121         if (p_mbctype[i] != prev)
 122         {
 123             printf("0x%x,%d, ", prev, count);
 124             prev = p_mbctype[i];
 125             count = 1;
 126         }
 127         else
 128             count++;
 129     }
 130     printf("0x%x,%d };\n", prev, count);
 131 }
 132
 133 #else
 134
 135 /* RLE-encoded mbctype tables for given codepages */
 136 static int result_cp_932_mbctype[] = { 0x0,65, 0x8,1, 0x18,26, 0x8,6, 0x28,26, 0x8,4,
 137   0x0,1, 0x8,1, 0xc,31, 0x8,1, 0xa,5, 0x9,58, 0xc,29, 0,3 };
 138 static int result_cp_936_mbctype[] = { 0x0,65, 0x8,1, 0x18,26, 0x8,6, 0x28,26, 0x8,6,
 139   0xc,126, 0,1 };
 140 static int result_cp_949_mbctype[] = { 0x0,66, 0x18,26, 0x8,6, 0x28,26, 0x8,6, 0xc,126,
 141   0,1 };
 142 static int result_cp_950_mbctype[] = { 0x0,65, 0x8,1, 0x18,26, 0x8,6, 0x28,26, 0x8,4,
 143   0x0,2, 0x4,32, 0xc,94, 0,1 };
 144
 145 static void test_cp_table(int cp, int *result)
 146 {
 147     int i;
 148     int count = 0;
 149     int curr = 0;
 150     _setmbcp(cp);
 151     for (i = 0; i < 256; i++)
 152     {
 153         if (count == 0)
 154         {
 155             curr = result[0];
 156             count = result[1];
 157             result += 2;
 158         }
 159         ok(p_mbctype[i] == curr, "CP%d: Mismatch in ctype for character %d - %d instead of %d\n", cp, i-1, p_mbctype[i], curr);
 160         count--;
 161     }
 162 }
 163
 164 #define test_codepage(num) test_cp_table(num, result_cp_##num##_mbctype);
 165
 166 #endif
 167
 168 static void test_mbcp(void)
 169 {
 170     int mb_orig_max = *p__mb_cur_max;
 171     int curr_mbcp = _getmbcp();
 172     unsigned char *mbstring = (unsigned char *)"\xb0\xb1\xb2 \xb3\xb4 \xb5"; /* incorrect string */
 173     unsigned char *mbstring2 = (unsigned char *)"\xb0\xb1\xb2\xb3Q\xb4\xb5"; /* correct string */
 174     unsigned char *mbsonlylead = (unsigned char *)"\xb0\0\xb1\xb2 \xb3";
 175     unsigned char buf[16];
 176     int step;
 177
 178     /* _mbtype tests */
 179
 180     /* An SBCS codepage test. The ctype of characters on e.g. CP1252 or CP1250 differs slightly
 181      * between versions of Windows. Also Windows 9x seems to ignore the codepage and always uses
 182      * CP1252 (or the ACP?) so we test only a few ASCII characters */
 183     _setmbcp(1252);
 184     expect_eq(p_mbctype[10], 0, char, "%x");
 185     expect_eq(p_mbctype[50], 0, char, "%x");
 186     expect_eq(p_mbctype[66], _SBUP, char, "%x");
 187     expect_eq(p_mbctype[100], _SBLOW, char, "%x");
 188     expect_eq(p_mbctype[128], 0, char, "%x");
 189     _setmbcp(1250);
 190     expect_eq(p_mbctype[10], 0, char, "%x");
 191     expect_eq(p_mbctype[50], 0, char, "%x");
 192     expect_eq(p_mbctype[66], _SBUP, char, "%x");
 193     expect_eq(p_mbctype[100], _SBLOW, char, "%x");
 194     expect_eq(p_mbctype[128], 0, char, "%x");
 195
 196     /* double byte code pages */
 197     test_codepage(932);
 198     test_codepage(936);
 199     test_codepage(949);
 200     test_codepage(950);
 201
 202     _setmbcp(936);
 203     ok(*p__mb_cur_max == mb_orig_max, "__mb_cur_max shouldn't be updated (is %d != %d)\n", *p__mb_cur_max, mb_orig_max);
 204     ok(_ismbblead('\354'), "\354 should be a lead byte\n");
 205     ok(_ismbblead(' ') == FALSE, "' ' should not be a lead byte\n");
 206     ok(_ismbblead(0x1234b0), "0x1234b0 should not be a lead byte\n");
 207     ok(_ismbblead(0x123420) == FALSE, "0x123420 should not be a lead byte\n");
 208     ok(_ismbbtrail('\xb0'), "\xa0 should be a trail byte\n");
 209     ok(_ismbbtrail(' ') == FALSE, "' ' should not be a trail byte\n");
 210
 211     /* _ismbslead */
 212     expect_eq(_ismbslead(mbstring, &mbstring[0]), -1, int, "%d");
 213     expect_eq(_ismbslead(mbstring, &mbstring[1]), FALSE, int, "%d");
 214     expect_eq(_ismbslead(mbstring, &mbstring[2]), -1, int, "%d");
 215     expect_eq(_ismbslead(mbstring, &mbstring[3]), FALSE, int, "%d");
 216     expect_eq(_ismbslead(mbstring, &mbstring[4]), -1, int, "%d");
 217     expect_eq(_ismbslead(mbstring, &mbstring[5]), FALSE, int, "%d");
 218     expect_eq(_ismbslead(mbstring, &mbstring[6]), FALSE, int, "%d");
 219     expect_eq(_ismbslead(mbstring, &mbstring[7]), -1, int, "%d");
 220     expect_eq(_ismbslead(mbstring, &mbstring[8]), FALSE, int, "%d");
 221
 222     expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[0]), -1, int, "%d");
 223     expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[1]), FALSE, int, "%d");
 224     expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[2]), FALSE, int, "%d");
 225     expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[5]), FALSE, int, "%d");
 226
 227     /* _ismbstrail */
 228     expect_eq(_ismbstrail(mbstring, &mbstring[0]), FALSE, int, "%d");
 229     expect_eq(_ismbstrail(mbstring, &mbstring[1]), -1, int, "%d");
 230     expect_eq(_ismbstrail(mbstring, &mbstring[2]), FALSE, int, "%d");
 231     expect_eq(_ismbstrail(mbstring, &mbstring[3]), -1, int, "%d");
 232     expect_eq(_ismbstrail(mbstring, &mbstring[4]), FALSE, int, "%d");
 233     expect_eq(_ismbstrail(mbstring, &mbstring[5]), -1, int, "%d");
 234     expect_eq(_ismbstrail(mbstring, &mbstring[6]), FALSE, int, "%d");
 235     expect_eq(_ismbstrail(mbstring, &mbstring[7]), FALSE, int, "%d");
 236     expect_eq(_ismbstrail(mbstring, &mbstring[8]), -1, int, "%d");
 237
 238     expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[0]), FALSE, int, "%d");
 239     expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[1]), -1, int, "%d");
 240     expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[2]), FALSE, int, "%d");
 241     expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[3]), FALSE, int, "%d");
 242     expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[4]), FALSE, int, "%d");
 243     expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[5]), FALSE, int, "%d");
 244
 245     /* _mbsbtype */
 246     expect_eq(_mbsbtype(mbstring, 0), _MBC_LEAD, int, "%d");
 247     expect_eq(_mbsbtype(mbstring, 1), _MBC_TRAIL, int, "%d");
 248     expect_eq(_mbsbtype(mbstring, 2), _MBC_LEAD, int, "%d");
 249     expect_eq(_mbsbtype(mbstring, 3), _MBC_ILLEGAL, int, "%d");
 250     expect_eq(_mbsbtype(mbstring, 4), _MBC_LEAD, int, "%d");
 251     expect_eq(_mbsbtype(mbstring, 5), _MBC_TRAIL, int, "%d");
 252     expect_eq(_mbsbtype(mbstring, 6), _MBC_SINGLE, int, "%d");
 253     expect_eq(_mbsbtype(mbstring, 7), _MBC_LEAD, int, "%d");
 254     expect_eq(_mbsbtype(mbstring, 8), _MBC_ILLEGAL, int, "%d");
 255
 256     expect_eq(_mbsbtype(mbsonlylead, 0), _MBC_LEAD, int, "%d");
 257     expect_eq(_mbsbtype(mbsonlylead, 1), _MBC_ILLEGAL, int, "%d");
 258     expect_eq(_mbsbtype(mbsonlylead, 2), _MBC_ILLEGAL, int, "%d");
 259     expect_eq(_mbsbtype(mbsonlylead, 3), _MBC_ILLEGAL, int, "%d");
 260     expect_eq(_mbsbtype(mbsonlylead, 4), _MBC_ILLEGAL, int, "%d");
 261     expect_eq(_mbsbtype(mbsonlylead, 5), _MBC_ILLEGAL, int, "%d");
 262
 263     /* _mbsnextc */
 264     expect_eq(_mbsnextc(mbstring), 0xb0b1, int, "%x");
 265     expect_eq(_mbsnextc(&mbstring[2]), 0xb220, int, "%x");  /* lead + invalid tail */
 266     expect_eq(_mbsnextc(&mbstring[3]), 0x20, int, "%x");    /* single char */
 267
 268     /* _mbclen/_mbslen */
 269     expect_eq(_mbclen(mbstring), 2, int, "%d");
 270     expect_eq(_mbclen(&mbstring[2]), 2, int, "%d");
 271     expect_eq(_mbclen(&mbstring[3]), 1, int, "%d");
 272     expect_eq(_mbslen(mbstring2), 4, int, "%d");
 273     expect_eq(_mbslen(mbsonlylead), 0, int, "%d");          /* lead + NUL not counted as character */
 274     expect_eq(_mbslen(mbstring), 4, int, "%d");             /* lead + invalid trail counted */
 275
 276     /* _mbccpy/_mbsncpy */
 277     memset(buf, 0xff, sizeof(buf));
 278     _mbccpy(buf, mbstring);
 279     expect_bin(buf, "\xb0\xb1\xff", 3);
 280
 281     memset(buf, 0xff, sizeof(buf));
 282     _mbsncpy(buf, mbstring, 1);
 283     expect_bin(buf, "\xb0\xb1\xff", 3);
 284     memset(buf, 0xff, sizeof(buf));
 285     _mbsncpy(buf, mbstring, 2);
 286     expect_bin(buf, "\xb0\xb1\xb2 \xff", 5);
 287     memset(buf, 0xff, sizeof(buf));
 288     _mbsncpy(buf, mbstring, 3);
 289     expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4\xff", 7);
 290     memset(buf, 0xff, sizeof(buf));
 291     _mbsncpy(buf, mbstring, 4);
 292     expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4 \xff", 8);
 293     memset(buf, 0xff, sizeof(buf));
 294     _mbsncpy(buf, mbstring, 5);
 295     expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4 \0\0\xff", 10);
 296     memset(buf, 0xff, sizeof(buf));
 297     _mbsncpy(buf, mbsonlylead, 6);
 298     expect_bin(buf, "\0\0\0\0\0\0\0\xff", 8);
 299
 300     memset(buf, 0xff, sizeof(buf));
 301     _mbsnbcpy(buf, mbstring2, 2);
 302     expect_bin(buf, "\xb0\xb1\xff", 3);
 303     _mbsnbcpy(buf, mbstring2, 3);
 304     expect_bin(buf, "\xb0\xb1\0\xff", 4);
 305     _mbsnbcpy(buf, mbstring2, 4);
 306     expect_bin(buf, "\xb0\xb1\xb2\xb3\xff", 5);
 307     memset(buf, 0xff, sizeof(buf));
 308     _mbsnbcpy(buf, mbsonlylead, 5);
 309     expect_bin(buf, "\0\0\0\0\0\xff", 6);
 310
 311     /* _mbsinc/mbsdec */
 312     step = _mbsinc(mbstring) - mbstring;
 313     ok(step == 2, "_mbsinc adds %d (exp. 2)\n", step);
 314     step = _mbsinc(&mbstring[2]) - &mbstring[2];  /* lead + invalid tail */
 315     ok(step == 2, "_mbsinc adds %d (exp. 2)\n", step);
 316
 317     step = _mbsninc(mbsonlylead, 1) - mbsonlylead;
 318     ok(step == 0, "_mbsninc adds %d (exp. 0)\n", step);
 319     step = _mbsninc(mbsonlylead, 2) - mbsonlylead;  /* lead + NUL byte + lead + char */
 320     ok(step == 0, "_mbsninc adds %d (exp. 0)\n", step);
 321     step = _mbsninc(mbstring2, 0) - mbstring2;
 322     ok(step == 0, "_mbsninc adds %d (exp. 2)\n", step);
 323     step = _mbsninc(mbstring2, 1) - mbstring2;
 324     ok(step == 2, "_mbsninc adds %d (exp. 2)\n", step);
 325     step = _mbsninc(mbstring2, 2) - mbstring2;
 326     ok(step == 4, "_mbsninc adds %d (exp. 4)\n", step);
 327     step = _mbsninc(mbstring2, 3) - mbstring2;
 328     ok(step == 5, "_mbsninc adds %d (exp. 5)\n", step);
 329     step = _mbsninc(mbstring2, 4) - mbstring2;
 330     ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
 331     step = _mbsninc(mbstring2, 5) - mbstring2;
 332     ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
 333     step = _mbsninc(mbstring2, 17) - mbstring2;
 334     ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
 335
 336     /* functions that depend on locale codepage, not mbcp.
 337      * we hope the current locale to be SBCS because setlocale(LC_ALL, ".1252") seems not to work yet
 338      * (as of Wine 0.9.43)
 339      */
 340     if (*p__mb_cur_max == 1)
 341     {
 342         expect_eq(mblen((char *)mbstring, 3), 1, int, "%x");
 343         expect_eq(_mbstrlen((char *)mbstring2), 7, int, "%d");
 344     }
 345     else
 346         skip("Current locale has double-byte charset - could leave to false positives\n");
 347
 348     _setmbcp(curr_mbcp);
 349 }
 350
 351 static void test_mbsspn( void)
 352 {
 353     unsigned char str1[]="cabernet";
 354     unsigned char str2[]="shiraz";
 355     unsigned char set[]="abc";
 356     unsigned char empty[]="";
 357     int ret;
 358     ret=_mbsspn( str1, set);
 359     ok( ret==3, "_mbsspn returns %d should be 3\n", ret);
 360     ret=_mbsspn( str2, set);
 361     ok( ret==0, "_mbsspn returns %d should be 0\n", ret);
 362     ret=_mbsspn( str1, empty);
 363     ok( ret==0, "_mbsspn returns %d should be 0\n", ret);
 364 }
 365
 366 static void test_mbsspnp( void)
 367 {
 368     unsigned char str1[]="cabernet";
 369     unsigned char str2[]="shiraz";
 370     unsigned char set[]="abc";
 371     unsigned char empty[]="";
 372     unsigned char full[]="abcenrt";
 373     unsigned char* ret;
 374     ret=_mbsspnp( str1, set);
 375     ok( ret[0]=='e', "_mbsspnp returns %c should be e\n", ret[0]);
 376     ret=_mbsspnp( str2, set);
 377     ok( ret[0]=='s', "_mbsspnp returns %c should be s\n", ret[0]);
 378     ret=_mbsspnp( str1, empty);
 379     ok( ret[0]=='c', "_mbsspnp returns %c should be c\n", ret[0]);
 380     ret=_mbsspnp( str1, full);
 381     ok( ret==NULL, "_mbsspnp returns %p should be NULL\n", ret);
 382 }
 383
 384 static void test_strdup(void)
 385 {
 386    char *str;
 387    str = _strdup( 0 );
 388    ok( str == 0, "strdup returns %s should be 0\n", str);
 389    free( str );
 390 }
 391
 392 static void test_strcpy_s(void)
 393 {
 394     char dest[8];
 395     const char *small = "small";
 396     const char *big = "atoolongstringforthislittledestination";
 397     int ret;
 398
 399     if(!pstrcpy_s)
 400     {
 401         skip("strcpy_s not found\n");
 402         return;
 403     }
 404
 405     memset(dest, 'X', sizeof(dest));
 406     ret = pstrcpy_s(dest, sizeof(dest), small);
 407     ok(ret == 0, "Copying a string into a big enough destination returned %d, expected 0\n", ret);
 408     ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 'l' &&
 409        dest[4] == 'l' && dest[5] == '\0'&& dest[6] == 'X' && dest[7] == 'X',
 410        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 411        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 412
 413     memset(dest, 'X', sizeof(dest));
 414     ret = pstrcpy_s(dest, 0, big);
 415     ok(ret == EINVAL, "Copying into a destination of size 0 returned %d, expected EINVAL\n", ret);
 416     ok(dest[0] == 'X' && dest[1] == 'X' && dest[2] == 'X' && dest[3] == 'X' &&
 417        dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 418        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 419        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 420     ret = pstrcpy_s(dest, 0, NULL);
 421     ok(ret == EINVAL, "Copying into a destination of size 0 returned %d, expected EINVAL\n", ret);
 422     ok(dest[0] == 'X' && dest[1] == 'X' && dest[2] == 'X' && dest[3] == 'X' &&
 423        dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 424        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 425        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 426
 427     memset(dest, 'X', sizeof(dest));
 428     ret = pstrcpy_s(dest, sizeof(dest), big);
 429     ok(ret == ERANGE, "Copying a big string in a small location returned %d, expected ERANGE\n", ret);
 430     ok(dest[0] == '\0'&& dest[1] == 't' && dest[2] == 'o' && dest[3] == 'o' &&
 431        dest[4] == 'l' && dest[5] == 'o' && dest[6] == 'n' && dest[7] == 'g',
 432        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 433        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 434
 435     memset(dest, 'X', sizeof(dest));
 436     ret = pstrcpy_s(dest, sizeof(dest), NULL);
 437     ok(ret == EINVAL, "Copying from a NULL source string returned %d, expected EINVAL\n", ret);
 438     ok(dest[0] == '\0'&& dest[1] == 'X' && dest[2] == 'X' && dest[3] == 'X' &&
 439        dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 440        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 441        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 442
 443     ret = pstrcpy_s(NULL, sizeof(dest), small);
 444     ok(ret == EINVAL, "Copying a big string a NULL dest returned %d, expected EINVAL\n", ret);
 445 }
 446
 447 static void test_strcat_s(void)
 448 {
 449     char dest[8];
 450     const char *small = "sma";
 451     int ret;
 452
 453     if(!pstrcat_s)
 454     {
 455         skip("strcat_s not found\n");
 456         return;
 457     }
 458
 459     memset(dest, 'X', sizeof(dest));
 460     dest[0] = '\0';
 461     ret = pstrcat_s(dest, sizeof(dest), small);
 462     ok(ret == 0, "strcat_s: Copying a string into a big enough destination returned %d, expected 0\n", ret);
 463     ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == '\0'&&
 464        dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 465        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 466        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 467     ret = pstrcat_s(dest, sizeof(dest), small);
 468     ok(ret == 0, "strcat_s: Attaching a string to a big enough destination returned %d, expected 0\n", ret);
 469     ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 's' &&
 470        dest[4] == 'm' && dest[5] == 'a' && dest[6] == '\0'&& dest[7] == 'X',
 471        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 472        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 473
 474     ret = pstrcat_s(dest, sizeof(dest), small);
 475     ok(ret == ERANGE, "strcat_s: Attaching a string to a filled up destination returned %d, expected ERANGE\n", ret);
 476     ok(dest[0] == '\0'&& dest[1] == 'm' && dest[2] == 'a' && dest[3] == 's' &&
 477        dest[4] == 'm' && dest[5] == 'a' && dest[6] == 's' && dest[7] == 'm',
 478        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 479        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 480
 481     memset(dest, 'X', sizeof(dest));
 482     dest[0] = 'a';
 483     dest[1] = '\0';
 484
 485     ret = pstrcat_s(dest, 0, small);
 486     ok(ret == EINVAL, "strcat_s: Source len = 0 returned %d, expected EINVAL\n", ret);
 487     ok(dest[0] == 'a' && dest[1] == '\0'&& dest[2] == 'X' && dest[3] == 'X' &&
 488        dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 489        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 490        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 491
 492     ret = pstrcat_s(dest, 0, NULL);
 493     ok(ret == EINVAL, "strcat_s: len = 0 and src = NULL returned %d, expected EINVAL\n", ret);
 494     ok(dest[0] == 'a' && dest[1] == '\0'&& dest[2] == 'X' && dest[3] == 'X' &&
 495        dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 496        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 497        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 498
 499     ret = pstrcat_s(dest, sizeof(dest), NULL);
 500     ok(ret == EINVAL, "strcat_s:  Sourcing from NULL returned %d, expected EINVAL\n", ret);
 501     ok(dest[0] == '\0'&& dest[1] == '\0'&& dest[2] == 'X' && dest[3] == 'X' &&
 502        dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 503        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 504        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 505
 506     ret = pstrcat_s(NULL, sizeof(dest), small);
 507     ok(ret == EINVAL, "strcat_s: Writing to a NULL string returned %d, expected EINVAL\n", ret);
 508 }
 509
 510 static void test__mbsnbcpy_s(void)
 511 {
 512     unsigned char dest[8];
 513     const unsigned char big[] = "atoolongstringforthislittledestination";
 514     const unsigned char small[] = "small";
 515     int ret;
 516
 517     if(!p_mbsnbcpy_s)
 518     {
 519         skip("_mbsnbcpy_s not found\n");
 520         return;
 521     }
 522
 523     memset(dest, 'X', sizeof(dest));
 524     ret = p_mbsnbcpy_s(dest, sizeof(dest), small, sizeof(small));
 525     ok(ret == 0, "_mbsnbcpy_s: Copying a string into a big enough destination returned %d, expected 0\n", ret);
 526     ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 'l' &&
 527        dest[4] == 'l' && dest[5] == '\0'&& dest[6] == 'X' && dest[7] == 'X',
 528        "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 529        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 530
 531     /* WTF? */
 532     memset(dest, 'X', sizeof(dest));
 533     ret = p_mbsnbcpy_s(dest, sizeof(dest) - 2, big, sizeof(small));
 534     ok(ret == ERANGE, "_mbsnbcpy_s: Copying a too long string returned %d, expected ERANGE\n", ret);
 535     ok(dest[0] == '\0'&& dest[1] == 't' && dest[2] == 'o' && dest[3] == 'o' &&
 536        dest[4] == 'l' && dest[5] == 'o' && dest[6] == 'X' && dest[7] == 'X',
 537        "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 538        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 539
 540     memset(dest, 'X', sizeof(dest));
 541     ret = p_mbsnbcpy_s(dest, sizeof(dest) - 2, big, 4);
 542     ok(ret == 0, "_mbsnbcpy_s: Copying a too long string with a count cap returned %d, expected 0\n", ret);
 543     ok(dest[0] == 'a' && dest[1] == 't' && dest[2] == 'o' && dest[3] == 'o' &&
 544        dest[4] == '\0'&& dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 545        "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 546        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 547
 548     memset(dest, 'X', sizeof(dest));
 549     ret = p_mbsnbcpy_s(dest, sizeof(dest) - 2, small, sizeof(small) + 10);
 550     ok(ret == 0, "_mbsnbcpy_s: Copying more data than the source string len returned %d, expected 0\n", ret);
 551     ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 'l' &&
 552        dest[4] == 'l' && dest[5] == '\0'&& dest[6] == 'X' && dest[7] == 'X',
 553        "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 554        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 555 }
 556
 557 static void test_wcscpy_s(void)
 558 {
 559     static const WCHAR szLongText[] = { 'T','h','i','s','A','L','o','n','g','s','t','r','i','n','g',0 };
 560     static WCHAR szDest[18];
 561     static WCHAR szDestShort[8];
 562     int ret;
 563
 564     if(!p_wcscpy_s)
 565     {
 566         skip("wcscpy_s not found\n");
 567         return;
 568     }
 569
 570     /* Test NULL Dest */
 571     ret = p_wcscpy_s(NULL, 18, szLongText);
 572     ok(ret == EINVAL, "p_wcscpy_s expect EINVAL got %d\n", ret);
 573
 574     /* Test NULL Source */
 575     szDest[0] = 'A';
 576     ret = p_wcscpy_s(szDest, 18, NULL);
 577     ok(ret == EINVAL, "expected EINVAL got %d\n", ret);
 578     ok(szDest[0] == 0, "szDest[0] not 0\n");
 579
 580     /* Test invalid size */
 581     szDest[0] = 'A';
 582     ret = p_wcscpy_s(szDest, 0, szLongText);
 583     /* Later versions changed the return value for this case to EINVAL,
 584      * and don't modify the result if the dest size is 0.
 585      */
 586     ok(ret == ERANGE || ret == EINVAL, "expected ERANGE/EINVAL got %d\n", ret);
 587     ok(szDest[0] == 0 || ret == EINVAL, "szDest[0] not 0\n");
 588
 589     /* Copy same buffer size */
 590     ret = p_wcscpy_s(szDest, 18, szLongText);
 591     ok(ret == 0, "expected 0 got %d\n", ret);
 592     ok(lstrcmpW(szDest, szLongText) == 0, "szDest != szLongText\n");
 593
 594     /* Copy smaller buffer size */
 595     szDest[0] = 'A';
 596     ret = p_wcscpy_s(szDestShort, 8, szLongText);
 597     ok(ret == ERANGE || ret == EINVAL, "expected ERANGE/EINVAL got %d\n", ret);
 598     ok(szDestShort[0] == 0, "szDestShort[0] not 0\n");
 599 }
 600
 601 static void test__wcsupr_s(void)
 602 {
 603     static const WCHAR mixedString[] = {'M', 'i', 'X', 'e', 'D', 'l', 'o', 'w',
 604                                         'e', 'r', 'U', 'P', 'P', 'E', 'R', 0};
 605     static const WCHAR expectedString[] = {'M', 'I', 'X', 'E', 'D', 'L', 'O',
 606                                            'W', 'E', 'R', 'U', 'P', 'P', 'E',
 607                                            'R', 0};
 608     WCHAR testBuffer[2*sizeof(mixedString)/sizeof(WCHAR)];
 609     int ret;
 610
 611     if (!p_wcsupr_s)
 612     {
 613         win_skip("_wcsupr_s not found\n");
 614         return;
 615     }
 616
 617     /* Test NULL input string and invalid size. */
 618     errno = EBADF;
 619     ret = p_wcsupr_s(NULL, 0);
 620     ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
 621     ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
 622
 623     /* Test NULL input string and valid size. */
 624     errno = EBADF;
 625     ret = p_wcsupr_s(NULL, sizeof(testBuffer)/sizeof(WCHAR));
 626     ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
 627     ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
 628
 629     /* Test empty string with zero size. */
 630     errno = EBADF;
 631     testBuffer[0] = '\0';
 632     ret = p_wcsupr_s(testBuffer, 0);
 633     ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
 634     ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
 635     ok(testBuffer[0] == '\0', "Expected the buffer to be unchanged\n");
 636
 637     /* Test empty string with size of one. */
 638     testBuffer[0] = '\0';
 639     ret = p_wcsupr_s(testBuffer, 1);
 640     ok(ret == 0, "Expected _wcsupr_s to succeed, got %d\n", ret);
 641     ok(testBuffer[0] == '\0', "Expected the buffer to be unchanged\n");
 642
 643     /* Test one-byte buffer with zero size. */
 644     errno = EBADF;
 645     testBuffer[0] = 'x';
 646     ret = p_wcsupr_s(testBuffer, 0);
 647     ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
 648     ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
 649     ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
 650
 651     /* Test one-byte buffer with size of one. */
 652     errno = EBADF;
 653     testBuffer[0] = 'x';
 654     ret = p_wcsupr_s(testBuffer, 1);
 655     ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
 656     ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
 657     ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
 658
 659     /* Test invalid size. */
 660     wcscpy(testBuffer, mixedString);
 661     errno = EBADF;
 662     ret = p_wcsupr_s(testBuffer, 0);
 663     ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
 664     ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
 665     ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
 666
 667     /* Test normal string uppercasing. */
 668     wcscpy(testBuffer, mixedString);
 669     ret = p_wcsupr_s(testBuffer, sizeof(mixedString)/sizeof(WCHAR));
 670     ok(ret == 0, "Expected _wcsupr_s to succeed, got %d\n", ret);
 671     ok(!wcscmp(testBuffer, expectedString), "Expected the string to be fully upper-case\n");
 672
 673     /* Test uppercasing with a shorter buffer size count. */
 674     wcscpy(testBuffer, mixedString);
 675     errno = EBADF;
 676     ret = p_wcsupr_s(testBuffer, sizeof(mixedString)/sizeof(WCHAR) - 1);
 677     ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
 678     ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
 679     ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
 680
 681     /* Test uppercasing with a longer buffer size count. */
 682     wcscpy(testBuffer, mixedString);
 683     ret = p_wcsupr_s(testBuffer, sizeof(testBuffer)/sizeof(WCHAR));
 684     ok(ret == 0, "Expected _wcsupr_s to succeed, got %d\n", ret);
 685     ok(!wcscmp(testBuffer, expectedString), "Expected the string to be fully upper-case\n");
 686 }
 687
 688 static void test_mbcjisjms(void)
 689 {
 690     /* List of value-pairs to test. The test assumes the last pair to be {0, ..} */
 691     unsigned int jisjms[][2] = { {0x2020, 0}, {0x2021, 0}, {0x2120, 0}, {0x2121, 0x8140},
 692                                  {0x7f7f, 0}, {0x7f7e, 0}, {0x7e7f, 0}, {0x7e7e, 0xeffc},
 693                                  {0x2121FFFF, 0}, {0x2223, 0x81a1}, {0x237e, 0x829e}, {0, 0}};
 694     unsigned int ret, exp, i;
 695
 696     i = 0;
 697     do
 698     {
 699         ret = _mbcjistojms(jisjms[i][0]);
 700
 701         if(_getmbcp() == 932)   /* Japanese codepage? */
 702             exp = jisjms[i][1];
 703         else
 704             exp = jisjms[i][0]; /* If not, no conversion */
 705
 706         ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
 707     } while(jisjms[i++][0] != 0);
 708 }
 709
 710 static const struct {
 711     const char* string;
 712     const char* delimiter;
 713     int exp_offsetret1; /* returned offset from string after first call to strtok()
 714                            -1 means NULL  */
 715     int exp_offsetret2; /* returned offset from string after second call to strtok()
 716                            -1 means NULL  */
 717     int exp_offsetret3; /* returned offset from string after third call to strtok()
 718                            -1 means NULL  */
 719 } testcases_strtok[] = {
 720     { "red cabernet", " ", 0, 4, -1 },
 721     { "sparkling white riesling", " ", 0, 10, 16 },
 722     { " pale cream sherry", "e ", 1, 6, 9 },
 723     /* end mark */
 724     { 0}
 725 };
 726
 727 static void test_strtok(void)
 728 {
 729     int i;
 730     char *strret;
 731     char teststr[100];
 732     for( i = 0; testcases_strtok[i].string; i++){
 733         strcpy( teststr, testcases_strtok[i].string);
 734         strret = strtok( teststr, testcases_strtok[i].delimiter);
 735         ok( (int)(strret - teststr) ==  testcases_strtok[i].exp_offsetret1 ||
 736                 (!strret && testcases_strtok[i].exp_offsetret1 == -1),
 737                 "string (%p) \'%s\' return %p\n",
 738                 teststr, testcases_strtok[i].string, strret);
 739         if( !strret) continue;
 740         strret = strtok( NULL, testcases_strtok[i].delimiter);
 741         ok( (int)(strret - teststr) ==  testcases_strtok[i].exp_offsetret2 ||
 742                 (!strret && testcases_strtok[i].exp_offsetret2 == -1),
 743                 "second call string (%p) \'%s\' return %p\n",
 744                 teststr, testcases_strtok[i].string, strret);
 745         if( !strret) continue;
 746         strret = strtok( NULL, testcases_strtok[i].delimiter);
 747         ok( (int)(strret - teststr) ==  testcases_strtok[i].exp_offsetret3 ||
 748                 (!strret && testcases_strtok[i].exp_offsetret3 == -1),
 749                 "third call string (%p) \'%s\' return %p\n",
 750                 teststr, testcases_strtok[i].string, strret);
 751     }
 752 }
 753
 754 static void test_strtol(void)
 755 {
 756     char* e;
 757     LONG l;
 758     ULONG ul;
 759
 760     /* errno is only set in case of error, so reset errno to EBADF to check for errno modification */
 761     /* errno is modified on W2K8+ */
 762     errno = EBADF;
 763     l = strtol("-1234", &e, 0);
 764     ok(l==-1234, "wrong value %d\n", l);
 765     ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
 766     errno = EBADF;
 767     ul = strtoul("1234", &e, 0);
 768     ok(ul==1234, "wrong value %u\n", ul);
 769     ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
 770
 771     errno = EBADF;
 772     l = strtol("2147483647L", &e, 0);
 773     ok(l==2147483647, "wrong value %d\n", l);
 774     ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
 775     errno = EBADF;
 776     l = strtol("-2147483648L", &e, 0);
 777     ok(l==-2147483647L - 1, "wrong value %d\n", l);
 778     ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
 779     errno = EBADF;
 780     ul = strtoul("4294967295UL", &e, 0);
 781     ok(ul==4294967295ul, "wrong value %u\n", ul);
 782     ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
 783
 784     errno = 0;
 785     l = strtol("9223372036854775807L", &e, 0);
 786     ok(l==2147483647, "wrong value %d\n", l);
 787     ok(errno == ERANGE, "wrong errno %d\n", errno);
 788     errno = 0;
 789     ul = strtoul("9223372036854775807L", &e, 0);
 790     ok(ul==4294967295ul, "wrong value %u\n", ul);
 791     ok(errno == ERANGE, "wrong errno %d\n", errno);
 792 }
 793
 794 START_TEST(string)
 795 {
 796     char mem[100];
 797     static const char xilstring[]="c:/xilinx";
 798     int nLen;
 799
 800     hMsvcrt = GetModuleHandleA("msvcrt.dll");
 801     if (!hMsvcrt)
 802         hMsvcrt = GetModuleHandleA("msvcrtd.dll");
 803     ok(hMsvcrt != 0, "GetModuleHandleA failed\n");
 804     SET(pmemcpy,"memcpy");
 805     SET(pmemcmp,"memcmp");
 806     SET(p_mbctype,"_mbctype");
 807     SET(p__mb_cur_max,"__mb_cur_max");
 808     pstrcpy_s = (void *)GetProcAddress( hMsvcrt,"strcpy_s" );
 809     pstrcat_s = (void *)GetProcAddress( hMsvcrt,"strcat_s" );
 810     p_mbsnbcpy_s = (void *)GetProcAddress( hMsvcrt,"_mbsnbcpy_s" );
 811     p_wcscpy_s = (void *)GetProcAddress( hMsvcrt,"wcscpy_s" );
 812     p_wcsupr_s = (void *)GetProcAddress( hMsvcrt,"_wcsupr_s" );
 813
 814     /* MSVCRT memcpy behaves like memmove for overlapping moves,
 815        MFC42 CString::Insert seems to rely on that behaviour */
 816     strcpy(mem,xilstring);
 817     nLen=strlen(xilstring);
 818     pmemcpy(mem+5, mem,nLen+1);
 819     ok(pmemcmp(mem+5,xilstring, nLen) == 0,
 820        "Got result %s\n",mem+5);
 821
 822     /* Test _swab function */
 823     test_swab();
 824
 825     /* Test ismbblead*/
 826     test_mbcp();
 827    /* test _mbsspn */
 828     test_mbsspn();
 829     test_mbsspnp();
 830    /* test _strdup */
 831     test_strdup();
 832     test_strcpy_s();
 833     test_strcat_s();
 834     test__mbsnbcpy_s();
 835     test_mbcjisjms();
 836     test_strtok();
 837     test_wcscpy_s();
 838     test__wcsupr_s();
 839     test_strtol();
 840 }