return buf[nr];
}
-static void __cdecl test_invalid_parameter_handler(const wchar_t *expression,
- const wchar_t *function, const wchar_t *file,
- unsigned line, uintptr_t arg)
-{
- /* we just ignore handler calls */
-}
-
#define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
#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)); }
static int* (__cdecl *pmemcmp)(void *, const void *, size_t n);
static int (__cdecl *pstrcpy_s)(char *dst, size_t len, const char *src);
static int (__cdecl *pstrcat_s)(char *dst, size_t len, const char *src);
+static int (__cdecl *p_mbscat_s)(unsigned char *dst, size_t size, const unsigned char *src);
static int (__cdecl *p_mbsnbcat_s)(unsigned char *dst, size_t size, const unsigned char *src, size_t count);
static int (__cdecl *p_mbsnbcpy_s)(unsigned char * dst, size_t size, const unsigned char * src, size_t count);
+static int (__cdecl *p__mbscpy_s)(unsigned char*, size_t, const unsigned char*);
static int (__cdecl *p_wcscpy_s)(wchar_t *wcDest, size_t size, const wchar_t *wcSrc);
static int (__cdecl *p_wcsncpy_s)(wchar_t *wcDest, size_t size, const wchar_t *wcSrc, size_t count);
static int (__cdecl *p_wcsncat_s)(wchar_t *dst, size_t elem, const wchar_t *src, size_t count);
static errno_t (__cdecl *p_ultoa_s)(__msvcrt_ulong,char*,size_t,int);
static int *p__mb_cur_max;
static unsigned char *p_mbctype;
-static _invalid_parameter_handler (__cdecl *p_set_invalid_parameter_handler)(_invalid_parameter_handler);
static int (__cdecl *p_wcslwr_s)(wchar_t*,size_t);
static errno_t (__cdecl *p_mbsupr_s)(unsigned char *str, size_t numberOfElements);
static errno_t (__cdecl *p_mbslwr_s)(unsigned char *str, size_t numberOfElements);
static size_t (__cdecl *p_mbrlen)(const char*, size_t, mbstate_t*);
static size_t (__cdecl *p_mbrtowc)(wchar_t*, const char*, size_t, mbstate_t*);
static int (__cdecl *p__atodbl_l)(_CRT_DOUBLE*,char*,_locale_t);
+static double (__cdecl *p__atof_l)(const char*,_locale_t);
+static double (__cdecl *p__strtod_l)(const char *,char**,_locale_t);
+static int (__cdecl *p__strnset_s)(char*,size_t,int,size_t);
+static int (__cdecl *p__wcsset_s)(wchar_t*,size_t,wchar_t);
#define SETNOFAIL(x,y) x = (void*)GetProcAddress(hMsvcrt,y)
#define SET(x,y) SETNOFAIL(x,y); ok(x != NULL, "Export '%s' not found\n", y)
if(!pstrcpy_s)
{
- skip("strcpy_s not found\n");
+ win_skip("strcpy_s not found\n");
return;
}
static const char big[] = {'a','t','o','o','l','o','n','g','s','t','r','i','n','g',0};
int ret;
if (!p_memcpy_s) {
- skip("memcpy_s not found\n");
+ win_skip("memcpy_s not found\n");
return;
}
- if (p_set_invalid_parameter_handler)
- ok(p_set_invalid_parameter_handler(test_invalid_parameter_handler) == NULL,
- "Invalid parameter handler was already set\n");
-
/* Normal */
memset(dest, 'X', sizeof(dest));
ret = p_memcpy_s(dest, NUMELMS(dest), tiny, NUMELMS(tiny));
ok(ret == EINVAL, "Copying a NULL buffer into a destination of size 0 returned %d, expected EINVAL\n", ret);
ok(errno == EINVAL, "errno is %d, expected EINVAL\n", errno);
okchars(dest, 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X');
-
- if (p_set_invalid_parameter_handler)
- ok(p_set_invalid_parameter_handler(NULL) == test_invalid_parameter_handler,
- "Cannot reset invalid parameter handler\n");
}
static void test_memmove_s(void)
static const char big[] = {'a','t','o','o','l','o','n','g','s','t','r','i','n','g',0};
int ret;
if (!p_memmove_s) {
- skip("memmove_s not found\n");
+ win_skip("memmove_s not found\n");
return;
}
- if (p_set_invalid_parameter_handler)
- ok(p_set_invalid_parameter_handler(test_invalid_parameter_handler) == NULL,
- "Invalid parameter handler was already set\n");
-
/* Normal */
memset(dest, 'X', sizeof(dest));
ret = p_memmove_s(dest, NUMELMS(dest), tiny, NUMELMS(tiny));
ok(ret == EINVAL, "Moving a NULL buffer into a destination of size 0 returned %d, expected EINVAL\n", ret);
ok(errno == EINVAL, "errno is %d, expected EINVAL\n", errno);
okchars(dest, 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X');
-
- if (p_set_invalid_parameter_handler)
- ok(p_set_invalid_parameter_handler(NULL) == test_invalid_parameter_handler,
- "Cannot reset invalid parameter handler\n");
}
static void test_strcat_s(void)
if(!pstrcat_s)
{
- skip("strcat_s not found\n");
+ win_skip("strcat_s not found\n");
return;
}
ok(ret == EINVAL, "strcat_s: Writing to a NULL string returned %d, expected EINVAL\n", ret);
}
+static void test__mbscat_s(void)
+{
+ unsigned char dst[8], src[4];
+ int err;
+ int prev_cp = _getmbcp();
+
+ if(!p_mbscat_s)
+ {
+ win_skip("_mbscat_s not found\n");
+ return;
+ }
+
+
+ src[0] = dst[0] = 0;
+ err = p_mbscat_s(NULL, sizeof(dst), src);
+ ok(err == EINVAL, "_mbscat_s returned %d\n", err);
+
+ err = p_mbscat_s(dst, sizeof(dst), NULL);
+ ok(err == EINVAL, "_mbscat_s returned %d\n", err);
+
+ dst[0] = 'a';
+ err = p_mbscat_s(dst, 1, src);
+ ok(err == EINVAL, "_mbscat_s returned %d\n", err);
+
+ memset(dst, 'a', sizeof(dst));
+ dst[6] = 0;
+ src[0] = 'b';
+ src[1] = 0;
+
+ err = p_mbscat_s(dst, sizeof(dst), src);
+ ok(err == 0, "_mbscat_s returned %d\n", err);
+ ok(!memcmp(dst, "aaaaaab", 8), "dst = %s\n", dst);
+
+ err = p_mbscat_s(dst, sizeof(dst), src);
+ ok(err == ERANGE, "_mbscat_s returned %d\n", err);
+ ok(!dst[0], "dst[0] = %c\n", dst[0]);
+ ok(dst[1] == 'a', "dst[1] = %c\n", dst[1]);
+
+ _setmbcp(932);
+ /* test invalid str in dst */
+ dst[0] = 0x81;
+ dst[1] = 0x81;
+ dst[2] = 0x52;
+ dst[3] = 0;
+ src[0] = 'a';
+ src[1] = 0;
+ err = p_mbscat_s(dst, sizeof(dst), src);
+ ok(err == 0, "_mbscat_s returned %d\n", err);
+
+ /* test invalid str in src */
+ dst[0] = 0;
+ src[0] = 0x81;
+ src[1] = 0x81;
+ src[2] = 0x52;
+ src[3] = 0;
+ err = p_mbscat_s(dst, sizeof(dst), src);
+ ok(err == 0, "_mbscat_s returned %d\n", err);
+
+ /* test dst with leading byte on the end of buffer */
+ dst[0] = 'a';
+ dst[1] = 0x81;
+ dst[2] = 0;
+ src[0] = 'R';
+ src[1] = 0;
+ err = p_mbscat_s(dst, sizeof(dst), src);
+ ok(err == EILSEQ, "_mbscat_s returned %d\n", err);
+ ok(!memcmp(dst, "aR", 3), "dst = %s\n", dst);
+
+ /* test src with leading byte on the end of buffer */
+ dst[0] = 'a';
+ dst[1] = 0;
+ src[0] = 'b';
+ src[1] = 0x81;
+ src[2] = 0;
+ err = p_mbscat_s(dst, sizeof(dst), src);
+ ok(err == EILSEQ, "_mbscat_s returned %d\n", err);
+ ok(!memcmp(dst, "ab", 3), "dst = %s\n", dst);
+ _setmbcp(prev_cp);
+}
+
static void test__mbsnbcpy_s(void)
{
unsigned char dest[8];
if(!p_mbsnbcpy_s)
{
- skip("_mbsnbcpy_s not found\n");
+ win_skip("_mbsnbcpy_s not found\n");
return;
}
dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
}
+static void test__mbscpy_s(void)
+{
+ const unsigned char src[] = "source string";
+ unsigned char dest[16];
+ int ret;
+
+ if(!p__mbscpy_s)
+ {
+ win_skip("_mbscpy_s not found\n");
+ return;
+ }
+
+ ret = p__mbscpy_s(NULL, 0, src);
+ ok(ret == EINVAL, "got %d\n", ret);
+ ret = p__mbscpy_s(NULL, sizeof(dest), src);
+ ok(ret == EINVAL, "got %d\n", ret);
+ ret = p__mbscpy_s(dest, 0, src);
+ ok(ret == EINVAL, "got %d\n", ret);
+ dest[0] = 'x';
+ ret = p__mbscpy_s(dest, sizeof(dest), NULL);
+ ok(ret == EINVAL, "got %d\n", ret);
+ ok(!dest[0], "dest buffer was not modified on invalid argument\n");
+
+ memset(dest, 'X', sizeof(dest));
+ ret = p__mbscpy_s(dest, sizeof(dest), src);
+ ok(!ret, "got %d\n", ret);
+ ok(!memcmp(dest, src, sizeof(src)), "dest = %s\n", dest);
+ ok(dest[sizeof(src)] == 'X', "unused part of buffer was modified\n");
+
+ memset(dest, 'X', sizeof(dest));
+ ret = p__mbscpy_s(dest, 4, src);
+ ok(ret == ERANGE, "got %d\n", ret);
+ ok(!dest[0], "incorrect dest buffer (%d)\n", dest[0]);
+ ok(dest[1] == src[1], "incorrect dest buffer (%d)\n", dest[1]);
+}
+
static void test_wcscpy_s(void)
{
static const WCHAR szLongText[] = { 'T','h','i','s','A','L','o','n','g','s','t','r','i','n','g',0 };
return;
}
- if (p_set_invalid_parameter_handler)
- ok(p_set_invalid_parameter_handler(test_invalid_parameter_handler) == NULL,
- "Invalid parameter handler was already set\n");
-
/* Test NULL Dest */
errno = EBADF;
ret = p_wcscpy_s(NULL, 18, szLongText);
if(!p_wcsncpy_s)
{
win_skip("wcsncpy_s not found\n");
-
- if (p_set_invalid_parameter_handler)
- ok(p_set_invalid_parameter_handler(NULL) == test_invalid_parameter_handler,
- "Cannot reset invalid parameter handler\n");
return;
}
ok(ret == STRUNCATE, "expected ERROR_SUCCESS got %d\n", ret);
ok(szDestShort[0]=='1' && szDestShort[1]=='1' && szDestShort[2]=='1' && szDestShort[3]=='1',
"szDestShort = %s\n", wine_dbgstr_w(szDestShort));
-
- if (p_set_invalid_parameter_handler)
- ok(p_set_invalid_parameter_handler(NULL) == test_invalid_parameter_handler,
- "Cannot reset invalid parameter handler\n");
}
static void test__wcsupr_s(void)
/* Test NULL input string and valid size. */
errno = EBADF;
- ret = p_wcslwr_s(NULL, sizeof(buffer)/sizeof(wchar_t));
+ ret = p_wcslwr_s(NULL, sizeof(buffer)/sizeof(buffer[0]));
ok(ret == EINVAL, "expected EINVAL, got %d\n", ret);
ok(errno == EINVAL, "expected errno EINVAL, got %d\n", errno);
_setmbcp(prev_cp);
}
+static void test_mbctohira(void)
+{
+ static const unsigned int mbchira_932[][2] = {
+ {0x8152, 0x8152}, {0x8153, 0x8153}, {0x8154, 0x8154}, {0x8155, 0x8155},
+ {0x82a0, 0x82a0}, {0x833f, 0x833f}, {0x8340, 0x829f}, {0x837e, 0x82dd},
+ {0x837f, 0x837f}, {0x8380, 0x82de}, {0x8393, 0x82f1}, {0x8394, 0x8394},
+ {0x8396, 0x8396}, {0x8397, 0x8397},
+ {0xa5, 0xa5}, {0xb0, 0xb0}, {0xdd, 0xdd} };
+ unsigned int i;
+ unsigned int prev_cp = _getmbcp();
+
+ _setmbcp(_MB_CP_SBCS);
+ for (i = 0; i < sizeof(mbchira_932)/sizeof(mbchira_932[0]); i++)
+ {
+ int ret, exp = mbchira_932[i][0];
+ ret = _mbctohira(mbchira_932[i][0]);
+ ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
+ }
+
+ _setmbcp(932);
+ for (i = 0; i < sizeof(mbchira_932)/sizeof(mbchira_932[0]); i++)
+ {
+ unsigned int ret, exp;
+ ret = _mbctohira(mbchira_932[i][0]);
+ exp = mbchira_932[i][1];
+ ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
+ }
+ _setmbcp(prev_cp);
+}
+
+static void test_mbctokata(void)
+{
+ static const unsigned int mbckata_932[][2] = {
+ {0x8152, 0x8152}, {0x8153, 0x8153}, {0x8154, 0x8154}, {0x8155, 0x8155},
+ {0x833f, 0x833f}, {0x829f, 0x8340}, {0x82dd, 0x837e}, {0x837f, 0x837f},
+ {0x82de, 0x8380}, {0x8394, 0x8394}, {0x8397, 0x8397},
+ {0xa5, 0xa5}, {0xb0, 0xb0}, {0xdd, 0xdd} };
+ unsigned int i;
+ unsigned int prev_cp = _getmbcp();
+
+ _setmbcp(_MB_CP_SBCS);
+ for (i = 0; i < sizeof(mbckata_932)/sizeof(mbckata_932[0]); i++)
+ {
+ int ret, exp = mbckata_932[i][0];
+ ret = _mbctokata(mbckata_932[i][0]);
+ ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
+ }
+
+ _setmbcp(932);
+ for (i = 0; i < sizeof(mbckata_932)/sizeof(mbckata_932[0]); i++)
+ {
+ unsigned int ret, exp;
+ ret = _mbctokata(mbckata_932[i][0]);
+ exp = mbckata_932[i][1];
+ ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
+ }
+ _setmbcp(prev_cp);
+}
+
static void test_mbbtombc(void)
{
static const unsigned int mbbmbc[][2] = {
_setmbcp(prev_cp);
}
+static void test_ismbckata(void) {
+ struct katakana_pair {
+ UINT c;
+ BOOL exp;
+ };
+ static const struct katakana_pair tests[] = {
+ {0x8152, FALSE}, {0x8153, FALSE}, {0x8154, FALSE}, {0x8155, FALSE},
+ {0x82a0, FALSE}, {0x833f, FALSE}, {0x8340, TRUE }, {0x837e, TRUE },
+ {0x837f, FALSE}, {0x8380, TRUE }, {0x8396, TRUE }, {0x8397, FALSE},
+ {0xa5, FALSE}, {0xb0, FALSE}, {0xdd, FALSE}
+ };
+ unsigned int prev_cp = _getmbcp();
+ int ret;
+ unsigned int i;
+
+ _setmbcp(_MB_CP_SBCS);
+ for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
+ ret = _ismbckata(tests[i].c);
+ ok(!ret, "expected 0, got %d for %04x\n", ret, tests[i].c);
+ }
+
+ _setmbcp(932);
+ for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
+ ret = _ismbckata(tests[i].c);
+ ok(!!ret == tests[i].exp, "expected %d, got %d for %04x\n",
+ tests[i].exp, !!ret, tests[i].c);
+ }
+
+ _setmbcp(prev_cp);
+}
+
static void test_ismbclegal(void) {
unsigned int prev_cp = _getmbcp();
int ret, exp, err;
static void test_strtol(void)
{
+ static char neg[] = "-0x";
+
char* e;
LONG l;
ULONG ul;
ul = strtoul("-4294967296", NULL, 0);
ok(ul == 1, "wrong value %u\n", ul);
ok(errno == ERANGE, "wrong errno %d\n", errno);
+
+ errno = 0;
+ l = strtol(neg, &e, 0);
+ ok(l == 0, "wrong value %d\n", l);
+ ok(errno == 0, "wrong errno %d\n", errno);
+ ok(e == neg, "e = %p, neg = %p\n", e, neg);
}
static void test_strnlen(void)
const char double3[] = "INF";
const char double4[] = ".21e12";
const char double5[] = "214353e-3";
+ const char double6[] = "NAN";
const char overflow[] = "1d9999999999999999999";
const char white_chars[] = " d10";
ok(almost_equal(d, 214.353), "d = %lf\n", d);
ok(end == double5+9, "incorrect end (%d)\n", (int)(end-double5));
+ d = strtod(double6, &end);
+ ok(almost_equal(d, 0), "d = %lf\n", d);
+ ok(end == double6, "incorrect end (%d)\n", (int)(end-double6));
+
d = strtod("12.1d2", NULL);
ok(almost_equal(d, 12.1e2), "d = %lf\n", d);
ok(almost_equal(d, 0), "d = %lf\n", d);
ok(end == white_chars, "incorrect end (%d)\n", (int)(end-white_chars));
+ if (!p__strtod_l)
+ win_skip("_strtod_l not found\n");
+ else
+ {
+ errno = EBADF;
+ d = strtod(NULL, NULL);
+ ok(almost_equal(d, 0.0), "d = %lf\n", d);
+ ok(errno == EINVAL, "errno = %x\n", errno);
+
+ errno = EBADF;
+ end = (char *)0xdeadbeef;
+ d = strtod(NULL, &end);
+ ok(almost_equal(d, 0.0), "d = %lf\n", d);
+ ok(errno == EINVAL, "errno = %x\n", errno);
+ ok(!end, "incorrect end ptr %p\n", end);
+
+ errno = EBADF;
+ d = p__strtod_l(NULL, NULL, NULL);
+ ok(almost_equal(d, 0.0), "d = %lf\n", d);
+ ok(errno == EINVAL, "errno = %x\n", errno);
+ }
+
/* Set locale with non '.' decimal point (',') */
if(!setlocale(LC_ALL, "Polish")) {
win_skip("system with limited locales\n");
ok(wOut[2] == 0, "wOut[2] = %x\n", wOut[2]);
ok(!pmbstr, "pmbstr != NULL\n");
- if (p_set_invalid_parameter_handler)
- ok(p_set_invalid_parameter_handler(test_invalid_parameter_handler) == NULL,
- "Invalid parameter handler was already set\n");
errno = EBADF;
ret = p_mbsrtowcs(wOut, NULL, 6, &state);
ok(ret == -1, "mbsrtowcs did not return -1\n");
ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
- if (p_set_invalid_parameter_handler)
- ok(p_set_invalid_parameter_handler(NULL) == test_invalid_parameter_handler,
- "Cannot reset invalid parameter handler\n");
setlocale(LC_ALL, "C");
}
return;
}
- if (p_set_invalid_parameter_handler)
- ok(p_set_invalid_parameter_handler(test_invalid_parameter_handler) == NULL,
- "Invalid parameter handler was already set\n");
-
errno = EBADF;
ret = p_itoa_s(0, NULL, 0, 0);
ok(ret == EINVAL, "Expected _itoa_s to return EINVAL, got %d\n", ret);
itoa(100, buffer, 100);
ok(!strcmp(buffer, "10"),
"Expected output buffer string to be \"10\", got \"%s\"\n", buffer);
-
- if (p_set_invalid_parameter_handler)
- ok(p_set_invalid_parameter_handler(NULL) == test_invalid_parameter_handler,
- "Cannot reset invalid parameter handler\n");
}
static void test__strlwr_s(void)
return;
}
- if (p_set_invalid_parameter_handler)
- ok(p_set_invalid_parameter_handler(test_invalid_parameter_handler) == NULL,
- "Invalid parameter handler was already set\n");
-
memcpy(src, abcW, sizeof(abcW));
dst[0] = 0;
ret = p_wcsncat_s(NULL, 4, src, 4);
dst[3] = 'd';
ret = p_wcsncat_s(dst, 4, src, 4);
ok(ret == EINVAL, "err = %d\n", ret);
-
- if (p_set_invalid_parameter_handler)
- ok(p_set_invalid_parameter_handler(NULL) == test_invalid_parameter_handler,
- "Cannot reset invalid parameter handler\n");
}
static void test__mbsnbcat_s(void)
static void test_tolower(void)
{
+ WCHAR chw, lower;
char ch, lch;
int ret, len;
ch = 0xF4;
errno = 0xdeadbeef;
ret = p_tolower(ch);
- len = LCMapStringA(0, LCMAP_LOWERCASE, &ch, 1, &lch, 1);
+ if(!MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, &ch, 1, &chw, 1) ||
+ LCMapStringW(CP_ACP, LCMAP_LOWERCASE, &chw, 1, &lower, 1) != 1 ||
+ (len = WideCharToMultiByte(CP_ACP, 0, &lower, 1, &lch, 1, NULL, NULL)) != 1)
+ len = 0;
if(len)
ok(ret==(unsigned char)lch || broken(ret==ch)/*WinXP-*/, "ret = %x\n", ret);
else
ch = 0xD0;
errno = 0xdeadbeef;
ret = p_tolower(ch);
- len = LCMapStringA(0, LCMAP_LOWERCASE, &ch, 1, &lch, 1);
+ if(!MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, &ch, 1, &chw, 1) ||
+ LCMapStringW(CP_ACP, LCMAP_LOWERCASE, &chw, 1, &lower, 1) != 1 ||
+ (len = WideCharToMultiByte(CP_ACP, 0, &lower, 1, &lch, 1, NULL, NULL)) != 1)
+ len = 0;
if(len)
ok(ret==(unsigned char)lch || broken(ret==ch)/*WinXP-*/, "ret = %x\n", ret);
else
ok(ret > 0, "_stricmp returned %d\n", ret);
ret = _stricmp("\xa5", "\xb9");
ok(ret == 0, "_stricmp returned %d\n", ret);
+ ret = _stricmp("a", "\xb9");
+ ok(ret < 0, "_stricmp returned %d\n", ret);
setlocale(LC_ALL, "C");
}
ok(r == 0, "atoi(4294967296) = %d\n", r);
}
+static void test_atof(void)
+{
+ double d;
+
+ d = atof("0.0");
+ ok(almost_equal(d, 0.0), "d = %lf\n", d);
+
+ d = atof("1.0");
+ ok(almost_equal(d, 1.0), "d = %lf\n", d);
+
+ d = atof("-1.0");
+ ok(almost_equal(d, -1.0), "d = %lf\n", d);
+
+ if (!p__atof_l)
+ {
+ win_skip("_atof_l not found\n");
+ return;
+ }
+
+ errno = EBADF;
+ d = atof(NULL);
+ ok(almost_equal(d, 0.0), "d = %lf\n", d);
+ ok(errno == EINVAL, "errno = %x\n", errno);
+
+ errno = EBADF;
+ d = p__atof_l(NULL, NULL);
+ ok(almost_equal(d, 0.0), "d = %lf\n", d);
+ ok(errno == EINVAL, "errno = %x\n", errno);
+}
+
static void test_strncpy(void)
{
#define TEST_STRNCPY_LEN 10
ok(!strncmp(dst, "0123456789", TEST_STRNCPY_LEN), "dst != 0123456789\n");
}
+static void test_strxfrm(void)
+{
+ char dest[256];
+ size_t ret;
+
+ /* crashes on old version of msvcrt */
+ if(p__atodbl_l) {
+ errno = 0xdeadbeef;
+ ret = strxfrm(NULL, "src", 1);
+ ok(ret == INT_MAX, "ret = %d\n", (int)ret);
+ ok(errno == EINVAL, "errno = %d\n", errno);
+
+ errno = 0xdeadbeef;
+ ret = strxfrm(dest, NULL, 100);
+ ok(ret == INT_MAX, "ret = %d\n", (int)ret);
+ ok(errno == EINVAL, "errno = %d\n", errno);
+ }
+
+ ret = strxfrm(NULL, "src", 0);
+ ok(ret == 3, "ret = %d\n", (int)ret);
+ dest[0] = 'a';
+ ret = strxfrm(dest, "src", 0);
+ ok(ret == 3, "ret = %d\n", (int)ret);
+ ok(dest[0] == 'a', "dest[0] = %d\n", dest[0]);
+
+ dest[3] = 'a';
+ ret = strxfrm(dest, "src", 5);
+ ok(ret == 3, "ret = %d\n", (int)ret);
+ ok(!strcmp(dest, "src"), "dest = %s\n", dest);
+
+ errno = 0xdeadbeef;
+ dest[1] = 'a';
+ ret = strxfrm(dest, "src", 1);
+ ok(ret == 3, "ret = %d\n", (int)ret);
+ ok(dest[0] == 's', "dest[0] = %d\n", dest[0]);
+ ok(dest[1] == 'a', "dest[1] = %d\n", dest[1]);
+ ok(errno == 0xdeadbeef, "errno = %d\n", errno);
+
+ ret = strxfrm(dest, "", 5);
+ ok(ret == 0, "ret = %d\n", (int)ret);
+ ok(!dest[0], "dest[0] = %d\n", dest[0]);
+
+ if(!setlocale(LC_ALL, "polish")) {
+ win_skip("stxfrm tests\n");
+ return;
+ }
+
+ ret = strxfrm(NULL, "src", 0);
+ ok(ret < sizeof(dest)-1, "ret = %d\n", (int)ret);
+ dest[0] = 'a';
+ ret = strxfrm(dest, "src", 0);
+ ok(ret < sizeof(dest)-1, "ret = %d\n", (int)ret);
+ ok(dest[0] == 'a', "dest[0] = %d\n", dest[0]);
+
+ ret = strxfrm(dest, "src", ret+1);
+ ok(ret < sizeof(dest)-1, "ret = %d\n", (int)ret);
+ ok(dest[0], "dest[0] = 0\n");
+
+ errno = 0xdeadbeef;
+ dest[0] = 'a';
+ ret = strxfrm(dest, "src", 5);
+ ok(ret>5 && ret<sizeof(dest)-1, "ret = %d\n", (int)ret);
+ ok(!dest[0] || broken(!p__atodbl_l && dest[0]=='a'), "dest[0] = %d\n", dest[0]);
+
+ setlocale(LC_ALL, "C");
+}
+
+static void test__strnset_s(void)
+{
+ char buf[5] = {0};
+ int r;
+
+ if(!p__strnset_s) {
+ win_skip("_strnset_s not available\n");
+ return;
+ }
+
+ r = p__strnset_s(NULL, 0, 'a', 0);
+ ok(r == 0, "r = %d\n", r);
+
+ buf[0] = buf[1] = buf[2] = 'b';
+ r = p__strnset_s(buf, sizeof(buf), 'a', 2);
+ ok(r == 0, "r = %d\n", r);
+ ok(!strcmp(buf, "aab"), "buf = %s\n", buf);
+
+ r = p__strnset_s(buf, 0, 'a', 0);
+ ok(r == EINVAL, "r = %d\n", r);
+
+ r = p__strnset_s(NULL, 0, 'a', 1);
+ ok(r == EINVAL, "r = %d\n", r);
+
+ buf[3] = 'b';
+ r = p__strnset_s(buf, sizeof(buf)-1, 'c', 2);
+ ok(r == EINVAL, "r = %d\n", r);
+ ok(!buf[0] && buf[1]=='c' && buf[2]=='b', "buf = %s\n", buf);
+}
+
+static void test__wcsset_s(void)
+{
+ wchar_t str[10];
+ int r;
+
+ if(!p__wcsset_s) {
+ win_skip("_wcsset_s not available\n");
+ return;
+ }
+
+ r = p__wcsset_s(NULL, 0, 'a');
+ ok(r == EINVAL, "r = %d\n", r);
+
+ str[0] = 'a';
+ r = p__wcsset_s(str, 0, 'a');
+ ok(r == EINVAL, "r = %d\n", r);
+ ok(str[0] == 'a', "str[0] = %d\n", str[0]);
+
+ str[0] = 'a';
+ str[1] = 'b';
+ r = p__wcsset_s(str, 2, 'c');
+ ok(r == EINVAL, "r = %d\n", r);
+ ok(!str[0], "str[0] = %d\n", str[0]);
+ ok(str[1] == 'b', "str[1] = %d\n", str[1]);
+
+ str[0] = 'a';
+ str[1] = 0;
+ str[2] = 'b';
+ r = p__wcsset_s(str, 3, 'c');
+ ok(str[0] == 'c', "str[0] = %d\n", str[0]);
+ ok(str[1] == 0, "str[1] = %d\n", str[1]);
+ ok(str[2] == 'b', "str[2] = %d\n", str[2]);
+}
+
+static void test__mbscmp(void)
+{
+ static const unsigned char a[] = {'a',0}, b[] = {'b',0};
+ int ret;
+
+ if (!p_mbrlen)
+ {
+ win_skip("_mbscmp tests\n");
+ return;
+ }
+
+ ret = _mbscmp(NULL, NULL);
+ ok(ret == INT_MAX, "got %d\n", ret);
+
+ ret = _mbscmp(a, NULL);
+ ok(ret == INT_MAX, "got %d\n", ret);
+
+ ret = _mbscmp(NULL, a);
+ ok(ret == INT_MAX, "got %d\n", ret);
+
+ ret = _mbscmp(a, a);
+ ok(!ret, "got %d\n", ret);
+
+ ret = _mbscmp(a, b);
+ ok(ret == -1, "got %d\n", ret);
+
+ ret = _mbscmp(b, a);
+ ok(ret == 1, "got %d\n", ret);
+}
+
START_TEST(string)
{
char mem[100];
SET(p__mb_cur_max,"__mb_cur_max");
pstrcpy_s = (void *)GetProcAddress( hMsvcrt,"strcpy_s" );
pstrcat_s = (void *)GetProcAddress( hMsvcrt,"strcat_s" );
+ p_mbscat_s = (void*)GetProcAddress( hMsvcrt, "_mbscat_s" );
p_mbsnbcat_s = (void *)GetProcAddress( hMsvcrt,"_mbsnbcat_s" );
p_mbsnbcpy_s = (void *)GetProcAddress( hMsvcrt,"_mbsnbcpy_s" );
+ p__mbscpy_s = (void *)GetProcAddress( hMsvcrt,"_mbscpy_s" );
p_wcscpy_s = (void *)GetProcAddress( hMsvcrt,"wcscpy_s" );
p_wcsncpy_s = (void *)GetProcAddress( hMsvcrt,"wcsncpy_s" );
p_wcsncat_s = (void *)GetProcAddress( hMsvcrt,"wcsncat_s" );
p_itoa_s = (void *)GetProcAddress(hMsvcrt, "_itoa_s");
p_strlwr_s = (void *)GetProcAddress(hMsvcrt, "_strlwr_s");
p_ultoa_s = (void *)GetProcAddress(hMsvcrt, "_ultoa_s");
- p_set_invalid_parameter_handler = (void *) GetProcAddress(hMsvcrt, "_set_invalid_parameter_handler");
p_wcslwr_s = (void*)GetProcAddress(hMsvcrt, "_wcslwr_s");
p_mbsupr_s = (void*)GetProcAddress(hMsvcrt, "_mbsupr_s");
p_mbslwr_s = (void*)GetProcAddress(hMsvcrt, "_mbslwr_s");
p_mbrtowc = (void*)GetProcAddress(hMsvcrt, "mbrtowc");
p_mbsrtowcs = (void*)GetProcAddress(hMsvcrt, "mbsrtowcs");
p__atodbl_l = (void*)GetProcAddress(hMsvcrt, "_atodbl_l");
+ p__atof_l = (void*)GetProcAddress(hMsvcrt, "_atof_l");
+ p__strtod_l = (void*)GetProcAddress(hMsvcrt, "_strtod_l");
+ p__strnset_s = (void*)GetProcAddress(hMsvcrt, "_strnset_s");
+ p__wcsset_s = (void*)GetProcAddress(hMsvcrt, "_wcsset_s");
/* MSVCRT memcpy behaves like memmove for overlapping moves,
MFC42 CString::Insert seems to rely on that behaviour */
test_memcpy_s();
test_memmove_s();
test_strcat_s();
+ test__mbscat_s();
test__mbsnbcpy_s();
+ test__mbscpy_s();
test_mbcjisjms();
test_mbcjmsjis();
+ test_mbctohira();
+ test_mbctokata();
test_mbbtombc();
test_mbctombb();
+ test_ismbckata();
test_ismbclegal();
test_strtok();
test__mbstok();
test__stricmp();
test__wcstoi64();
test_atoi();
+ test_atof();
test_strncpy();
+ test_strxfrm();
+ test__strnset_s();
+ test__wcsset_s();
+ test__mbscmp();
}
projects / reactos.git / blobdiff