rostests/winetests/msvcrt/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 size_t _mbstrlen(const char*);
  32
  33 static char *buf_to_string(const unsigned char *bin, int len, int nr)
  34 {
  35     static char buf[2][1024];
  36     char *w = buf[nr];
  37     int i;
  38
  39     for (i = 0; i < len; i++)
  40     {
  41         sprintf(w, "%02x ", (unsigned char)bin[i]);
  42         w += strlen(w);
  43     }
  44     return buf[nr];
  45 }
  46
  47 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
  48 #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)); }
  49
  50 static void* (*pmemcpy)(void *, const void *, size_t n);
  51 static int* (*pmemcmp)(void *, const void *, size_t n);
  52 static int (*pstrcpy_s)(char *dst, size_t len, const char *src);
  53 static int (*pstrcat_s)(char *dst, size_t len, const char *src);
  54 static int (*p_mbsnbcpy_s)(unsigned char * dst, size_t size, const unsigned char * src, size_t count);
  55 static int (*p_wcscpy_s)(wchar_t *wcDest, size_t size, const wchar_t *wcSrc);
  56
  57 #define SETNOFAIL(x,y) x = (void*)GetProcAddress(hMsvcrt,y)
  58 #define SET(x,y) SETNOFAIL(x,y); ok(x != NULL, "Export '%s' not found\n", y)
  59
  60 HMODULE hMsvcrt;
  61
  62 static void test_swab( void ) {
  63     char original[]  = "BADCFEHGJILKNMPORQTSVUXWZY@#";
  64     char expected1[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ@#";
  65     char expected2[] = "ABCDEFGHIJKLMNOPQRSTUVWX$";
  66     char expected3[] = "$";
  67
  68     char from[30];
  69     char to[30];
  70
  71     int testsize;
  72
  73     /* Test 1 - normal even case */
  74     memset(to,'$', sizeof(to));
  75     memset(from,'@', sizeof(from));
  76     testsize = 26;
  77     memcpy(from, original, testsize);
  78     _swab( from, to, testsize );
  79     ok(memcmp(to,expected1,testsize) == 0, "Testing even size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
  80
  81     /* Test 2 - uneven case  */
  82     memset(to,'$', sizeof(to));
  83     memset(from,'@', sizeof(from));
  84     testsize = 25;
  85     memcpy(from, original, testsize);
  86     _swab( from, to, testsize );
  87     ok(memcmp(to,expected2,testsize) == 0, "Testing odd size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
  88
  89     /* Test 3 - from = to */
  90     memset(to,'$', sizeof(to));
  91     memset(from,'@', sizeof(from));
  92     testsize = 26;
  93     memcpy(to, original, testsize);
  94     _swab( to, to, testsize );
  95     ok(memcmp(to,expected1,testsize) == 0, "Testing overlapped size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
  96
  97     /* Test 4 - 1 bytes */
  98     memset(to,'$', sizeof(to));
  99     memset(from,'@', sizeof(from));
 100     testsize = 1;
 101     memcpy(from, original, testsize);
 102     _swab( from, to, testsize );
 103     ok(memcmp(to,expected3,testsize) == 0, "Testing small size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
 104 }
 105
 106 #if 0      /* use this to generate more tests */
 107
 108 static void test_codepage(int cp)
 109 {
 110     int i;
 111     int prev;
 112     int count = 1;
 113
 114     ok(_setmbcp(cp) == 0, "Couldn't set mbcp\n");
 115
 116     prev = _mbctype[0];
 117     printf("static int result_cp_%d_mbctype[] = { ", cp);
 118     for (i = 1; i < 257; i++)
 119     {
 120         if (_mbctype[i] != prev)
 121         {
 122             printf("0x%x,%d, ", prev, count);
 123             prev = _mbctype[i];
 124             count = 1;
 125         }
 126         else
 127             count++;
 128     }
 129     printf("0x%x,%d };\n", prev, count);
 130 }
 131
 132 #define test_codepage_todo(cp, todo) test_codepage(cp)
 133
 134 /* RLE-encoded mbctype tables for given codepages */
 135 static int result_cp_932_mbctype[] = { 0x0,65, 0x8,1, 0x18,26, 0x8,6, 0x28,26, 0x8,4,
 136   0x0,1, 0x8,1, 0xc,31, 0x8,1, 0xa,5, 0x9,58, 0xc,29, 0,3 };
 137 static int result_cp_936_mbctype[] = { 0x0,65, 0x8,1, 0x18,26, 0x8,6, 0x28,26, 0x8,6,
 138   0xc,126, 0,1 };
 139 static int result_cp_949_mbctype[] = { 0x0,66, 0x18,26, 0x8,6, 0x28,26, 0x8,6, 0xc,126,
 140   0,1 };
 141 static int result_cp_950_mbctype[] = { 0x0,65, 0x8,1, 0x18,26, 0x8,6, 0x28,26, 0x8,4,
 142   0x0,2, 0x4,32, 0xc,94, 0,1 };
 143
 144 static int todo_none[] = { -2 };
 145 static int todo_cp_932[] = { 254, -2 };
 146
 147 void test_cp_table(int cp, int *result, int *todo)
 148 {
 149     int i;
 150     int count = 0;
 151     int curr = 0;
 152     _setmbcp(cp);
 153     for (i = 0; i < 256; i++)
 154     {
 155         if (count == 0)
 156         {
 157             curr = result[0];
 158             count = result[1];
 159             result += 2;
 160         }
 161         if (i == *todo + 1)
 162         {
 163             todo_wine ok(_mbctype[i] == curr, "CP%d: Mismatch in ctype for character %d - %d instead of %d\n", cp, i-1, _mbctype[i], curr);
 164             todo++;
 165         }
 166         else
 167             ok(_mbctype[i] == curr, "CP%d: Mismatch in ctype for character %d - %d instead of %d\n", cp, i-1, _mbctype[i], curr);
 168         count--;
 169     }
 170 }
 171
 172 #define test_codepage(num) test_cp_table(num, result_cp_##num##_mbctype, todo_none);
 173 #define test_codepage_todo(num, todo) test_cp_table(num, result_cp_##num##_mbctype, todo);
 174
 175 #endif
 176
 177
 178 static void test_mbcp(void)
 179 {
 180     int mb_orig_max = __mb_cur_max;
 181     int curr_mbcp = _getmbcp();
 182     unsigned char *mbstring = (unsigned char *)"\xb0\xb1\xb2 \xb3\xb4 \xb5"; /* incorrect string */
 183     unsigned char *mbstring2 = (unsigned char *)"\xb0\xb1\xb2\xb3Q\xb4\xb5"; /* correct string */
 184     unsigned char *mbsonlylead = (unsigned char *)"\xb0\0\xb1\xb2 \xb3";
 185     unsigned char buf[16];
 186     int step;
 187
 188     /* _mbtype tests */
 189
 190     /* An SBCS codepage test. The ctype of characters on e.g. CP1252 or CP1250 differs slightly
 191      * between versions of Windows. Also Windows 9x seems to ignore the codepage and always uses
 192      * CP1252 (or the ACP?) so we test only a few ASCII characters */
 193     _setmbcp(1252);
 194     expect_eq(_mbctype[10], 0, char, "%x");
 195     expect_eq(_mbctype[50], 0, char, "%x");
 196     expect_eq(_mbctype[66], _SBUP, char, "%x");
 197     expect_eq(_mbctype[100], _SBLOW, char, "%x");
 198     expect_eq(_mbctype[128], 0, char, "%x");
 199     _setmbcp(1250);
 200     expect_eq(_mbctype[10], 0, char, "%x");
 201     expect_eq(_mbctype[50], 0, char, "%x");
 202     expect_eq(_mbctype[66], _SBUP, char, "%x");
 203     expect_eq(_mbctype[100], _SBLOW, char, "%x");
 204     expect_eq(_mbctype[128], 0, char, "%x");
 205
 206     /* double byte code pages */
 207     //test_codepage_todo(932, todo_cp_932);
 208     //test_codepage(936);
 209     //test_codepage(949);
 210     //test_codepage(950);
 211
 212     _setmbcp(936);
 213     ok(__mb_cur_max == mb_orig_max, "__mb_cur_max shouldn't be updated (is %d != %d)\n", __mb_cur_max, mb_orig_max);
 214     ok(_ismbblead('\354'), "\354 should be a lead byte\n");
 215     ok(_ismbblead(' ') == FALSE, "' ' should not be a lead byte\n");
 216     ok(_ismbblead(0x1234b0), "0x1234b0 should not be a lead byte\n");
 217     ok(_ismbblead(0x123420) == FALSE, "0x123420 should not be a lead byte\n");
 218     ok(_ismbbtrail('\xb0'), "\xa0 should be a trail byte\n");
 219     ok(_ismbbtrail(' ') == FALSE, "' ' should not be a trail byte\n");
 220
 221     /* _ismbslead */
 222     expect_eq(_ismbslead(mbstring, &mbstring[0]), -1, int, "%d");
 223     expect_eq(_ismbslead(mbstring, &mbstring[1]), FALSE, int, "%d");
 224     expect_eq(_ismbslead(mbstring, &mbstring[2]), -1, int, "%d");
 225     expect_eq(_ismbslead(mbstring, &mbstring[3]), FALSE, int, "%d");
 226     expect_eq(_ismbslead(mbstring, &mbstring[4]), -1, int, "%d");
 227     expect_eq(_ismbslead(mbstring, &mbstring[5]), FALSE, int, "%d");
 228     expect_eq(_ismbslead(mbstring, &mbstring[6]), FALSE, int, "%d");
 229     expect_eq(_ismbslead(mbstring, &mbstring[7]), -1, int, "%d");
 230     expect_eq(_ismbslead(mbstring, &mbstring[8]), FALSE, int, "%d");
 231
 232     expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[0]), -1, int, "%d");
 233     expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[1]), FALSE, int, "%d");
 234     expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[2]), FALSE, int, "%d");
 235     expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[5]), FALSE, int, "%d");
 236
 237     /* _ismbstrail */
 238     expect_eq(_ismbstrail(mbstring, &mbstring[0]), FALSE, int, "%d");
 239     expect_eq(_ismbstrail(mbstring, &mbstring[1]), -1, int, "%d");
 240     expect_eq(_ismbstrail(mbstring, &mbstring[2]), FALSE, int, "%d");
 241     expect_eq(_ismbstrail(mbstring, &mbstring[3]), -1, int, "%d");
 242     expect_eq(_ismbstrail(mbstring, &mbstring[4]), FALSE, int, "%d");
 243     expect_eq(_ismbstrail(mbstring, &mbstring[5]), -1, int, "%d");
 244     expect_eq(_ismbstrail(mbstring, &mbstring[6]), FALSE, int, "%d");
 245     expect_eq(_ismbstrail(mbstring, &mbstring[7]), FALSE, int, "%d");
 246     expect_eq(_ismbstrail(mbstring, &mbstring[8]), -1, int, "%d");
 247
 248     expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[0]), FALSE, int, "%d");
 249     expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[1]), -1, int, "%d");
 250     expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[2]), FALSE, int, "%d");
 251     expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[3]), FALSE, int, "%d");
 252     expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[4]), FALSE, int, "%d");
 253     expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[5]), FALSE, int, "%d");
 254
 255     /* _mbsbtype */
 256     expect_eq(_mbsbtype(mbstring, 0), _MBC_LEAD, int, "%d");
 257     expect_eq(_mbsbtype(mbstring, 1), _MBC_TRAIL, int, "%d");
 258     expect_eq(_mbsbtype(mbstring, 2), _MBC_LEAD, int, "%d");
 259     expect_eq(_mbsbtype(mbstring, 3), _MBC_ILLEGAL, int, "%d");
 260     expect_eq(_mbsbtype(mbstring, 4), _MBC_LEAD, int, "%d");
 261     expect_eq(_mbsbtype(mbstring, 5), _MBC_TRAIL, int, "%d");
 262     expect_eq(_mbsbtype(mbstring, 6), _MBC_SINGLE, int, "%d");
 263     expect_eq(_mbsbtype(mbstring, 7), _MBC_LEAD, int, "%d");
 264     expect_eq(_mbsbtype(mbstring, 8), _MBC_ILLEGAL, int, "%d");
 265
 266     expect_eq(_mbsbtype(mbsonlylead, 0), _MBC_LEAD, int, "%d");
 267     expect_eq(_mbsbtype(mbsonlylead, 1), _MBC_ILLEGAL, int, "%d");
 268     expect_eq(_mbsbtype(mbsonlylead, 2), _MBC_ILLEGAL, int, "%d");
 269     expect_eq(_mbsbtype(mbsonlylead, 3), _MBC_ILLEGAL, int, "%d");
 270     expect_eq(_mbsbtype(mbsonlylead, 4), _MBC_ILLEGAL, int, "%d");
 271     expect_eq(_mbsbtype(mbsonlylead, 5), _MBC_ILLEGAL, int, "%d");
 272
 273     /* _mbsnextc */
 274     expect_eq(_mbsnextc(mbstring), 0xb0b1, int, "%x");
 275     expect_eq(_mbsnextc(&mbstring[2]), 0xb220, int, "%x");  /* lead + invalid tail */
 276     expect_eq(_mbsnextc(&mbstring[3]), 0x20, int, "%x");    /* single char */
 277
 278     /* _mbclen/_mbslen */
 279     expect_eq(_mbclen(mbstring), 2, int, "%d");
 280     expect_eq(_mbclen(&mbstring[2]), 2, int, "%d");
 281     expect_eq(_mbclen(&mbstring[3]), 1, int, "%d");
 282     expect_eq(_mbslen(mbstring2), 4, int, "%d");
 283     expect_eq(_mbslen(mbsonlylead), 0, int, "%d");          /* lead + NUL not counted as character */
 284     expect_eq(_mbslen(mbstring), 4, int, "%d");             /* lead + invalid trail counted */
 285
 286     /* _mbccpy/_mbsncpy */
 287     memset(buf, 0xff, sizeof(buf));
 288     _mbccpy(buf, mbstring);
 289     expect_bin(buf, "\xb0\xb1\xff", 3);
 290
 291     memset(buf, 0xff, sizeof(buf));
 292     _mbsncpy(buf, mbstring, 1);
 293     expect_bin(buf, "\xb0\xb1\xff", 3);
 294     memset(buf, 0xff, sizeof(buf));
 295     _mbsncpy(buf, mbstring, 2);
 296     expect_bin(buf, "\xb0\xb1\xb2 \xff", 5);
 297     memset(buf, 0xff, sizeof(buf));
 298     _mbsncpy(buf, mbstring, 3);
 299     expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4\xff", 7);
 300     memset(buf, 0xff, sizeof(buf));
 301     _mbsncpy(buf, mbstring, 4);
 302     expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4 \xff", 8);
 303     memset(buf, 0xff, sizeof(buf));
 304     _mbsncpy(buf, mbstring, 5);
 305     expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4 \0\0\xff", 10);
 306     memset(buf, 0xff, sizeof(buf));
 307     _mbsncpy(buf, mbsonlylead, 6);
 308     expect_bin(buf, "\0\0\0\0\0\0\0\xff", 8);
 309
 310     memset(buf, 0xff, sizeof(buf));
 311     _mbsnbcpy(buf, mbstring2, 2);
 312     expect_bin(buf, "\xb0\xb1\xff", 3);
 313     _mbsnbcpy(buf, mbstring2, 3);
 314     expect_bin(buf, "\xb0\xb1\0\xff", 4);
 315     _mbsnbcpy(buf, mbstring2, 4);
 316     expect_bin(buf, "\xb0\xb1\xb2\xb3\xff", 5);
 317     memset(buf, 0xff, sizeof(buf));
 318     _mbsnbcpy(buf, mbsonlylead, 5);
 319     expect_bin(buf, "\0\0\0\0\0\xff", 6);
 320
 321     /* _mbsinc/mbsdec */
 322     step = _mbsinc(mbstring) - mbstring;
 323     ok(step == 2, "_mbsinc adds %d (exp. 2)\n", step);
 324     step = _mbsinc(&mbstring[2]) - &mbstring[2];  /* lead + invalid tail */
 325     ok(step == 2, "_mbsinc adds %d (exp. 2)\n", step);
 326
 327     step = _mbsninc(mbsonlylead, 1) - mbsonlylead;
 328     ok(step == 0, "_mbsninc adds %d (exp. 0)\n", step);
 329     step = _mbsninc(mbsonlylead, 2) - mbsonlylead;  /* lead + NUL byte + lead + char */
 330     ok(step == 0, "_mbsninc adds %d (exp. 0)\n", step);
 331     step = _mbsninc(mbstring2, 0) - mbstring2;
 332     ok(step == 0, "_mbsninc adds %d (exp. 2)\n", step);
 333     step = _mbsninc(mbstring2, 1) - mbstring2;
 334     ok(step == 2, "_mbsninc adds %d (exp. 2)\n", step);
 335     step = _mbsninc(mbstring2, 2) - mbstring2;
 336     ok(step == 4, "_mbsninc adds %d (exp. 4)\n", step);
 337     step = _mbsninc(mbstring2, 3) - mbstring2;
 338     ok(step == 5, "_mbsninc adds %d (exp. 5)\n", step);
 339     step = _mbsninc(mbstring2, 4) - mbstring2;
 340     ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
 341     step = _mbsninc(mbstring2, 5) - mbstring2;
 342     ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
 343     step = _mbsninc(mbstring2, 17) - mbstring2;
 344     ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
 345
 346     /* functions that depend on locale codepage, not mbcp.
 347      * we hope the current locale to be SBCS because setlocale(LC_ALL, ".1252") seems not to work yet
 348      * (as of Wine 0.9.43)
 349      */
 350     if (__mb_cur_max == 1)
 351     {
 352         expect_eq(mblen((char *)mbstring, 3), 1, int, "%x");
 353         expect_eq(_mbstrlen((char *)mbstring2), 7, int, "%d");
 354     }
 355     else
 356         skip("Current locale has double-byte charset - could leave to false positives\n");
 357
 358     _setmbcp(curr_mbcp);
 359 }
 360
 361 static void test_mbsspn( void)
 362 {
 363     unsigned char str1[]="cabernet";
 364     unsigned char str2[]="shiraz";
 365     unsigned char set[]="abc";
 366     unsigned char empty[]="";
 367     int ret;
 368     ret=_mbsspn( str1, set);
 369     ok( ret==3, "_mbsspn returns %d should be 3\n", ret);
 370     ret=_mbsspn( str2, set);
 371     ok( ret==0, "_mbsspn returns %d should be 0\n", ret);
 372     ret=_mbsspn( str1, empty);
 373     ok( ret==0, "_mbsspn returns %d should be 0\n", ret);
 374 }
 375
 376 static void test_mbsspnp( void)
 377 {
 378     unsigned char str1[]="cabernet";
 379     unsigned char str2[]="shiraz";
 380     unsigned char set[]="abc";
 381     unsigned char empty[]="";
 382     unsigned char full[]="abcenrt";
 383     unsigned char* ret;
 384     ret=_mbsspnp( str1, set);
 385     ok( ret[0]=='e', "_mbsspnp returns %c should be e\n", ret[0]);
 386     ret=_mbsspnp( str2, set);
 387     ok( ret[0]=='s', "_mbsspnp returns %c should be s\n", ret[0]);
 388     ret=_mbsspnp( str1, empty);
 389     ok( ret[0]=='c', "_mbsspnp returns %c should be c\n", ret[0]);
 390     ret=_mbsspnp( str1, full);
 391     ok( ret==NULL, "_mbsspnp returns %p should be NULL\n", ret);
 392 }
 393
 394 static void test_strdup(void)
 395 {
 396    char *str;
 397    str = _strdup( 0 );
 398    ok( str == 0, "strdup returns %s should be 0\n", str);
 399    free( str );
 400 }
 401
 402 static void test_strcpy_s(void)
 403 {
 404     char dest[8];
 405     const char *small = "small";
 406     const char *big = "atoolongstringforthislittledestination";
 407     int ret;
 408
 409     if(!pstrcpy_s)
 410     {
 411         skip("strcpy_s not found\n");
 412         return;
 413     }
 414
 415     memset(dest, 'X', sizeof(dest));
 416     ret = pstrcpy_s(dest, sizeof(dest), small);
 417     ok(ret == 0, "Copying a string into a big enough destination returned %d, expected 0\n", ret);
 418     ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 'l' &&
 419        dest[4] == 'l' && dest[5] == '\0'&& dest[6] == 'X' && dest[7] == 'X',
 420        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 421        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 422
 423     memset(dest, 'X', sizeof(dest));
 424     ret = pstrcpy_s(dest, 0, big);
 425     ok(ret == EINVAL, "Copying into a destination of size 0 returned %d, expected EINVAL\n", ret);
 426     ok(dest[0] == 'X' && dest[1] == 'X' && dest[2] == 'X' && dest[3] == 'X' &&
 427        dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 428        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 429        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 430     ret = pstrcpy_s(dest, 0, NULL);
 431     ok(ret == EINVAL, "Copying into a destination of size 0 returned %d, expected EINVAL\n", ret);
 432     ok(dest[0] == 'X' && dest[1] == 'X' && dest[2] == 'X' && dest[3] == 'X' &&
 433        dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 434        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 435        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 436
 437     memset(dest, 'X', sizeof(dest));
 438     ret = pstrcpy_s(dest, sizeof(dest), big);
 439     ok(ret == ERANGE, "Copying a big string in a small location returned %d, expected ERANGE\n", ret);
 440     ok(dest[0] == '\0'&& dest[1] == 't' && dest[2] == 'o' && dest[3] == 'o' &&
 441        dest[4] == 'l' && dest[5] == 'o' && dest[6] == 'n' && dest[7] == 'g',
 442        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 443        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 444
 445     memset(dest, 'X', sizeof(dest));
 446     ret = pstrcpy_s(dest, sizeof(dest), NULL);
 447     ok(ret == EINVAL, "Copying from a NULL source string returned %d, expected EINVAL\n", ret);
 448     ok(dest[0] == '\0'&& dest[1] == 'X' && dest[2] == 'X' && dest[3] == 'X' &&
 449        dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 450        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 451        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 452
 453     ret = pstrcpy_s(NULL, sizeof(dest), small);
 454     ok(ret == EINVAL, "Copying a big string a NULL dest returned %d, expected EINVAL\n", ret);
 455 }
 456
 457 static void test_strcat_s(void)
 458 {
 459     char dest[8];
 460     const char *small = "sma";
 461     int ret;
 462
 463     if(!pstrcat_s)
 464     {
 465         skip("strcat_s not found\n");
 466         return;
 467     }
 468
 469     memset(dest, 'X', sizeof(dest));
 470     dest[0] = '\0';
 471     ret = pstrcat_s(dest, sizeof(dest), small);
 472     ok(ret == 0, "strcat_s: Copying a string into a big enough destination returned %d, expected 0\n", ret);
 473     ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == '\0'&&
 474        dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 475        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 476        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 477     ret = pstrcat_s(dest, sizeof(dest), small);
 478     ok(ret == 0, "strcat_s: Attaching a string to a big enough destination returned %d, expected 0\n", ret);
 479     ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 's' &&
 480        dest[4] == 'm' && dest[5] == 'a' && dest[6] == '\0'&& dest[7] == 'X',
 481        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 482        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 483
 484     ret = pstrcat_s(dest, sizeof(dest), small);
 485     ok(ret == ERANGE, "strcat_s: Attaching a string to a filled up destination returned %d, expected ERANGE\n", ret);
 486     ok(dest[0] == '\0'&& dest[1] == 'm' && dest[2] == 'a' && dest[3] == 's' &&
 487        dest[4] == 'm' && dest[5] == 'a' && dest[6] == 's' && dest[7] == 'm',
 488        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 489        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 490
 491     memset(dest, 'X', sizeof(dest));
 492     dest[0] = 'a';
 493     dest[1] = '\0';
 494
 495     ret = pstrcat_s(dest, 0, small);
 496     ok(ret == EINVAL, "strcat_s: Source len = 0 returned %d, expected EINVAL\n", ret);
 497     ok(dest[0] == 'a' && dest[1] == '\0'&& dest[2] == 'X' && dest[3] == 'X' &&
 498        dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 499        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 500        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 501
 502     ret = pstrcat_s(dest, 0, NULL);
 503     ok(ret == EINVAL, "strcat_s: len = 0 and src = NULL returned %d, expected EINVAL\n", ret);
 504     ok(dest[0] == 'a' && dest[1] == '\0'&& dest[2] == 'X' && dest[3] == 'X' &&
 505        dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 506        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 507        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 508
 509     ret = pstrcat_s(dest, sizeof(dest), NULL);
 510     ok(ret == EINVAL, "strcat_s:  Sourcing from NULL returned %d, expected EINVAL\n", ret);
 511     ok(dest[0] == '\0'&& dest[1] == '\0'&& dest[2] == 'X' && dest[3] == 'X' &&
 512        dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 513        "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 514        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 515
 516     ret = pstrcat_s(NULL, sizeof(dest), small);
 517     ok(ret == EINVAL, "strcat_s: Writing to a NULL string returned %d, expected EINVAL\n", ret);
 518 }
 519
 520 static void test__mbsnbcpy_s(void)
 521 {
 522     unsigned char dest[8];
 523     const unsigned char big[] = "atoolongstringforthislittledestination";
 524     const unsigned char small[] = "small";
 525     int ret;
 526
 527     if(!p_mbsnbcpy_s)
 528     {
 529         skip("_mbsnbcpy_s not found\n");
 530         return;
 531     }
 532
 533     memset(dest, 'X', sizeof(dest));
 534     ret = p_mbsnbcpy_s(dest, sizeof(dest), small, sizeof(small));
 535     ok(ret == 0, "_mbsnbcpy_s: Copying a string into a big enough destination returned %d, expected 0\n", ret);
 536     ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 'l' &&
 537        dest[4] == 'l' && dest[5] == '\0'&& dest[6] == 'X' && dest[7] == 'X',
 538        "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 539        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 540
 541     /* WTF? */
 542     memset(dest, 'X', sizeof(dest));
 543     ret = p_mbsnbcpy_s(dest, sizeof(dest) - 2, big, sizeof(small));
 544     ok(ret == ERANGE, "_mbsnbcpy_s: Copying a too long string returned %d, expected ERANGE\n", ret);
 545     ok(dest[0] == '\0'&& dest[1] == 't' && dest[2] == 'o' && dest[3] == 'o' &&
 546        dest[4] == 'l' && dest[5] == 'o' && dest[6] == 'X' && dest[7] == 'X',
 547        "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 548        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 549
 550     memset(dest, 'X', sizeof(dest));
 551     ret = p_mbsnbcpy_s(dest, sizeof(dest) - 2, big, 4);
 552     ok(ret == 0, "_mbsnbcpy_s: Copying a too long string with a count cap returned %d, expected 0\n", ret);
 553     ok(dest[0] == 'a' && dest[1] == 't' && dest[2] == 'o' && dest[3] == 'o' &&
 554        dest[4] == '\0'&& dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
 555        "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 556        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 557
 558     memset(dest, 'X', sizeof(dest));
 559     ret = p_mbsnbcpy_s(dest, sizeof(dest) - 2, small, sizeof(small) + 10);
 560     ok(ret == 0, "_mbsnbcpy_s: Copying more data than the source string len returned %d, expected 0\n", ret);
 561     ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 'l' &&
 562        dest[4] == 'l' && dest[5] == '\0'&& dest[6] == 'X' && dest[7] == 'X',
 563        "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 564        dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 565 }
 566
 567 static void test_wcscpy_s(void)
 568 {
 569     static const WCHAR szLongText[] = { 'T','h','i','s','A','L','o','n','g','s','t','r','i','n','g',0 };
 570     static WCHAR szDest[18];
 571     static WCHAR szDestShort[8];
 572     int ret;
 573
 574     if(!p_wcscpy_s)
 575     {
 576         skip("wcscpy_s not found\n");
 577         return;
 578     }
 579
 580     /* Test NULL Dest */
 581     ret = p_wcscpy_s(NULL, 18, szLongText);
 582     ok(ret == EINVAL, "p_wcscpy_s expect EINVAL got %d\n", ret);
 583
 584     /* Test NULL Source */
 585     szDest[0] = 'A';
 586     ret = p_wcscpy_s(szDest, 18, NULL);
 587     ok(ret == EINVAL, "expected EINVAL got %d\n", ret);
 588     ok(szDest[0] == 0, "szDest[0] not 0\n");
 589
 590     /* Test invalid size */
 591     szDest[0] = 'A';
 592     ret = p_wcscpy_s(szDest, 0, szLongText);
 593     /* Later versions changed the return value for this case to EINVAL,
 594      * and don't modify the result if the dest size is 0.
 595      */
 596     ok(ret == ERANGE || ret == EINVAL, "expected ERANGE/EINVAL got %d\n", ret);
 597     ok(szDest[0] == 0 || ret == EINVAL, "szDest[0] not 0\n");
 598
 599     /* Copy same buffer size */
 600     ret = p_wcscpy_s(szDest, 18, szLongText);
 601     ok(ret == 0, "expected 0 got %d\n", ret);
 602     ok(lstrcmpW(szDest, szLongText) == 0, "szDest != szLongText\n");
 603
 604     /* Copy smaller buffer size */
 605     szDest[0] = 'A';
 606     ret = p_wcscpy_s(szDestShort, 8, szLongText);
 607     ok(ret == ERANGE || ret == EINVAL, "expected ERANGE/EINVAL got %d\n", ret);
 608     ok(szDestShort[0] == 0, "szDestShort[0] not 0\n");
 609 }
 610
 611 START_TEST(string)
 612 {
 613     char mem[100];
 614     static const char xilstring[]="c:/xilinx";
 615     int nLen;
 616
 617     hMsvcrt = GetModuleHandleA("msvcrt.dll");
 618     if (!hMsvcrt)
 619         hMsvcrt = GetModuleHandleA("msvcrtd.dll");
 620     ok(hMsvcrt != 0, "GetModuleHandleA failed\n");
 621     SET(pmemcpy,"memcpy");
 622     SET(pmemcmp,"memcmp");
 623     pstrcpy_s = (void *)GetProcAddress( hMsvcrt,"strcpy_s" );
 624     pstrcat_s = (void *)GetProcAddress( hMsvcrt,"strcat_s" );
 625     p_mbsnbcpy_s = (void *)GetProcAddress( hMsvcrt,"_mbsnbcpy_s" );
 626     p_wcscpy_s = (void *)GetProcAddress( hMsvcrt,"wcscpy_s" );
 627
 628     /* MSVCRT memcpy behaves like memmove for overlapping moves,
 629        MFC42 CString::Insert seems to rely on that behaviour */
 630     strcpy(mem,xilstring);
 631     nLen=strlen(xilstring);
 632     pmemcpy(mem+5, mem,nLen+1);
 633     ok(pmemcmp(mem+5,xilstring, nLen) == 0,
 634        "Got result %s\n",mem+5);
 635
 636     /* Test _swab function */
 637     test_swab();
 638
 639     /* Test ismbblead*/
 640     test_mbcp();
 641    /* test _mbsspn */
 642     test_mbsspn();
 643     test_mbsspnp();
 644    /* test _strdup */
 645     test_strdup();
 646     test_strcpy_s();
 647     test_strcat_s();
 648     test__mbsnbcpy_s();
 649
 650     test_wcscpy_s();
 651 }