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)
_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;
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(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(!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];
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__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