ReactOS 0.4.15-dev-8145-ga541a46
string.c File Reference
#include <stdio.h>
#include "wine/test.h"
#include "winbase.h"
#include "winerror.h"
#include "winnls.h"
#include "shlwapi.h"
#include "shtypes.h"
Include dependency graph for string.c:

Go to the source code of this file.

Classes

struct  tagStrToIntResult
 
struct  tagStrFormatSizeResult
 
struct  tagStrFromTimeIntervalResult
 

Macros

#define NO_SHLWAPI_REG
 
#define NO_SHLWAPI_PATH
 
#define NO_SHLWAPI_GDI
 
#define NO_SHLWAPI_STREAM
 
#define expect_eq(expr, val, type, fmt)
 
#define expect_eq2(expr, val1, val2, type, fmt)
 
#define check_strrstri(type, str, pos, needle, exp)
 

Typedefs

typedef struct tagStrToIntResult StrToIntResult
 
typedef struct tagStrFormatSizeResult StrFormatSizeResult
 
typedef struct tagStrFromTimeIntervalResult StrFromTimeIntervalResult
 

Functions

static BOOL (WINAPI *pChrCmpIA)(CHAR
 
static DWORD (WINAPI *pSHAnsiToAnsi)(LPCSTR
 
static LPSTR (WINAPI *pStrCatBuffA)(LPSTR
 
static LPWSTR (WINAPI *pStrCatBuffW)(LPWSTR
 
static HRESULT (WINAPI *pStrRetToBSTR)(STRRET *
 
static INT (WINAPIV *pwnsprintfA)(LPSTR
 
static LONGLONG *static LONGLONG *static int strcmpW (const WCHAR *str1, const WCHAR *str2)
 
static BOOL is_lang_english (void)
 
static BOOL is_locale_english (void)
 
static void test_StrChrA (void)
 
static void test_StrChrW (void)
 
static void test_StrChrIA (void)
 
static void test_StrChrIW (void)
 
static void test_StrRChrA (void)
 
static void test_StrRChrW (void)
 
static void test_StrCpyW (void)
 
static void test_StrChrNW (void)
 
static void test_StrToIntA (void)
 
static void test_StrToIntW (void)
 
static void test_StrToIntExA (void)
 
static void test_StrToIntExW (void)
 
static void test_StrToInt64ExA (void)
 
static void test_StrToInt64ExW (void)
 
static void test_StrDupA (void)
 
static void test_StrFormatByteSize64A (void)
 
static void test_StrFormatKBSizeW (void)
 
static void test_StrFormatKBSizeA (void)
 
static void test_StrFromTimeIntervalA (void)
 
static void test_StrCmpA (void)
 
static void test_StrCmpW (void)
 
static WCHARCoDupStrW (const char *src)
 
static void test_StrRetToBSTR (void)
 
static void test_StrCpyNXA (void)
 
static void test_StrCpyNXW (void)
 
static void test_StrRStrI (void)
 
static void test_SHAnsiToAnsi (void)
 
static void test_SHUnicodeToUnicode (void)
 
static void test_StrXXX_overflows (void)
 
static void test_StrStrA (void)
 
static void test_StrStrW (void)
 
static void test_StrStrIA (void)
 
static void test_StrStrIW (void)
 
static void test_StrStrNW (void)
 
static void test_StrStrNIW (void)
 
static void test_StrCatChainW (void)
 
 START_TEST (string)
 

Variables

static CHAR
 
static WCHAR
 
static LPCSTR
 
static int
 
static LPCWSTR
 
static LPSTR
 
static LPWSTR
 
static INT
 
static DWORD
 
static UINT
 
static WORD
 
static LPCITEMIDLIST
 
static const StrToIntResult StrToInt_results []
 
static const StrFormatSizeResult StrFormatSize_results []
 
static const StrFromTimeIntervalResult StrFromTimeInterval_results []
 

Macro Definition Documentation

◆ check_strrstri

#define check_strrstri (   type,
  str,
  pos,
  needle,
  exp 
)
Value:
ret##type = StrRStrI##type(str, str+pos, needle); \
ok(ret##type == (exp), "Type " #type ", expected %p but got %p (string base %p)\n", \
(exp), ret##type, str);
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
DWORD exp
Definition: msg.c:16058
const WCHAR * str
#define StrRStrI
Definition: shlwapi.h:1633
int ret

Definition at line 895 of file string.c.

◆ expect_eq

#define expect_eq (   expr,
  val,
  type,
  fmt 
)
Value:
do { \
type ret = expr; \
ok(ret == val, "Unexpected value of '" #expr "': " #fmt " instead of " #val "\n", ret); \
} while (0);
GLuint GLfloat * val
Definition: glext.h:7180
Definition: query.h:87
Definition: dsound.c:943

Definition at line 33 of file string.c.

◆ expect_eq2

#define expect_eq2 (   expr,
  val1,
  val2,
  type,
  fmt 
)
Value:
do { \
type ret = expr; \
ok(ret == val1 || ret == val2, "Unexpected value of '" #expr "': " #fmt " instead of " #val1 " or " #val2 "\n", ret); \
} while (0);

Definition at line 38 of file string.c.

◆ NO_SHLWAPI_GDI

#define NO_SHLWAPI_GDI

Definition at line 28 of file string.c.

◆ NO_SHLWAPI_PATH

#define NO_SHLWAPI_PATH

Definition at line 27 of file string.c.

◆ NO_SHLWAPI_REG

#define NO_SHLWAPI_REG

Definition at line 26 of file string.c.

◆ NO_SHLWAPI_STREAM

#define NO_SHLWAPI_STREAM

Definition at line 29 of file string.c.

Typedef Documentation

◆ StrFormatSizeResult

◆ StrFromTimeIntervalResult

◆ StrToIntResult

Function Documentation

◆ BOOL()

static BOOL ( WINAPI pChrCmpIA)
static

◆ CoDupStrW()

static WCHAR * CoDupStrW ( const char src)
static

Definition at line 807 of file string.c.

808{
809 INT len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
810 WCHAR* szTemp = CoTaskMemAlloc(len * sizeof(WCHAR));
811 MultiByteToWideChar(CP_ACP, 0, src, -1, szTemp, len);
812 return szTemp;
813}
#define NULL
Definition: types.h:112
#define CP_ACP
Definition: compat.h:109
#define MultiByteToWideChar
Definition: compat.h:110
GLenum src
Definition: glext.h:6340
GLenum GLsizei len
Definition: glext.h:6722
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:426
int32_t INT
Definition: typedefs.h:58
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ DWORD()

static DWORD ( WINAPI pSHAnsiToAnsi)
static

◆ HRESULT()

static HRESULT ( WINAPI pStrRetToBSTR)
static

◆ INT()

static INT ( WINAPIV pwnsprintfA)
static

◆ is_lang_english()

static BOOL is_lang_english ( void  )
static

Definition at line 209 of file string.c.

210{
211 static HMODULE hkernel32 = NULL;
212 static LANGID (WINAPI *pGetThreadUILanguage)(void) = NULL;
213 static LANGID (WINAPI *pGetUserDefaultUILanguage)(void) = NULL;
214
215 if (!hkernel32)
216 {
217 hkernel32 = GetModuleHandleA("kernel32.dll");
218 pGetThreadUILanguage = (void*)GetProcAddress(hkernel32, "GetThreadUILanguage");
219 pGetUserDefaultUILanguage = (void*)GetProcAddress(hkernel32, "GetUserDefaultUILanguage");
220 }
221 if (pGetThreadUILanguage)
222 return PRIMARYLANGID(pGetThreadUILanguage()) == LANG_ENGLISH;
223 if (pGetUserDefaultUILanguage)
224 return PRIMARYLANGID(pGetUserDefaultUILanguage()) == LANG_ENGLISH;
225
227}
#define GetProcAddress(x, y)
Definition: compat.h:753
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
LANGID WINAPI GetUserDefaultLangID(void)
Definition: locale.c:1176
USHORT LANGID
Definition: mui.h:9
static HINSTANCE hkernel32
Definition: process.c:66
#define LANG_ENGLISH
Definition: nls.h:52
#define PRIMARYLANGID(l)
Definition: nls.h:16
#define WINAPI
Definition: msvc.h:6

Referenced by START_TEST().

◆ is_locale_english()

static BOOL is_locale_english ( void  )
static

Definition at line 232 of file string.c.

233{
234 /* Surprisingly GetThreadLocale() is irrelevant here */
236}

Referenced by START_TEST().

◆ LPSTR()

static LPSTR ( WINAPI pStrCatBuffA)
static

◆ LPWSTR()

static LPWSTR ( WINAPI pStrCatBuffW)
static

◆ START_TEST()

START_TEST ( string  )

Definition at line 1623 of file string.c.

1624{
1626 CHAR thousandDelim[8];
1627 CHAR decimalDelim[8];
1628 CoInitialize(0);
1629
1632
1633 hShlwapi = GetModuleHandleA("shlwapi");
1634 pChrCmpIA = (void *)GetProcAddress(hShlwapi, "ChrCmpIA");
1635 pChrCmpIW = (void *)GetProcAddress(hShlwapi, "ChrCmpIW");
1636 pIntlStrEqWorkerA = (void *)GetProcAddress(hShlwapi, "IntlStrEqWorkerA");
1637 pIntlStrEqWorkerW = (void *)GetProcAddress(hShlwapi, "IntlStrEqWorkerW");
1638 pSHAnsiToAnsi = (void *)GetProcAddress(hShlwapi, (LPSTR)345);
1639 pSHUnicodeToUnicode = (void *)GetProcAddress(hShlwapi, (LPSTR)346);
1640 pStrCatBuffA = (void *)GetProcAddress(hShlwapi, "StrCatBuffA");
1641 pStrCatBuffW = (void *)GetProcAddress(hShlwapi, "StrCatBuffW");
1642 pStrCatChainW = (void *)GetProcAddress(hShlwapi, "StrCatChainW");
1643 pStrCpyNXA = (void *)GetProcAddress(hShlwapi, (LPSTR)399);
1644 pStrCpyNXW = (void *)GetProcAddress(hShlwapi, (LPSTR)400);
1645 pStrChrNW = (void *)GetProcAddress(hShlwapi, "StrChrNW");
1646 pStrFormatByteSize64A = (void *)GetProcAddress(hShlwapi, "StrFormatByteSize64A");
1647 pStrFormatKBSizeA = (void *)GetProcAddress(hShlwapi, "StrFormatKBSizeA");
1648 pStrFormatKBSizeW = (void *)GetProcAddress(hShlwapi, "StrFormatKBSizeW");
1649 pStrIsIntlEqualA = (void *)GetProcAddress(hShlwapi, "StrIsIntlEqualA");
1650 pStrIsIntlEqualW = (void *)GetProcAddress(hShlwapi, "StrIsIntlEqualW");
1651 pStrPBrkW = (void *)GetProcAddress(hShlwapi, "StrPBrkW");
1652 pStrRChrA = (void *)GetProcAddress(hShlwapi, "StrRChrA");
1653 pStrRetToBSTR = (void *)GetProcAddress(hShlwapi, "StrRetToBSTR");
1654 pStrRetToBufA = (void *)GetProcAddress(hShlwapi, "StrRetToBufA");
1655 pStrRetToBufW = (void *)GetProcAddress(hShlwapi, "StrRetToBufW");
1656 pStrStrNW = (void *)GetProcAddress(hShlwapi, "StrStrNW");
1657 pStrStrNIW = (void *)GetProcAddress(hShlwapi, "StrStrNIW");
1658 pwnsprintfA = (void *)GetProcAddress(hShlwapi, "wnsprintfA");
1659 pwnsprintfW = (void *)GetProcAddress(hShlwapi, "wnsprintfW");
1660 pStrToInt64ExA = (void *)GetProcAddress(hShlwapi, "StrToInt64ExA");
1661 pStrToInt64ExW = (void *)GetProcAddress(hShlwapi, "StrToInt64ExW");
1662
1663 test_StrChrA();
1664 test_StrChrW();
1665 test_StrChrIA();
1666 test_StrChrIW();
1667 test_StrRChrA();
1668 test_StrRChrW();
1669 test_StrCpyW();
1670 test_StrChrNW();
1677 test_StrDupA();
1678
1679 /* language-dependent test */
1681 {
1685 }
1686 else
1687 skip("An English UI and locale is required for the StrFormat*Size tests\n");
1688 if (is_lang_english())
1690 else
1691 skip("An English UI is required for the StrFromTimeInterval tests\n");
1692
1693 test_StrCmpA();
1694 test_StrCmpW();
1698 test_StrRStrI();
1702 test_StrStrA();
1703 test_StrStrW();
1704 test_StrStrIA();
1705 test_StrStrIW();
1706 test_StrStrNW();
1709
1711}
#define skip(...)
Definition: atltest.h:64
static HMODULE hShlwapi
Definition: clsid.c:38
INT WINAPI GetLocaleInfoA(LCID lcid, LCTYPE lctype, LPSTR buffer, INT len)
Definition: locale.c:1599
HRESULT WINAPI CoInitialize(LPVOID lpReserved)
Definition: compobj.c:1964
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
static void test_StrFormatByteSize64A(void)
Definition: string.c:659
static void test_StrChrIW(void)
Definition: string.c:316
static void test_StrStrIW(void)
Definition: string.c:1272
static void test_StrChrW(void)
Definition: string.c:264
static void test_StrFormatKBSizeA(void)
Definition: string.c:705
static BOOL is_locale_english(void)
Definition: string.c:232
static void test_StrStrNW(void)
Definition: string.c:1328
static void test_StrDupA(void)
Definition: string.c:633
static void test_StrCmpA(void)
Definition: string.c:745
static void test_StrStrIA(void)
Definition: string.c:1224
static void test_StrToInt64ExW(void)
Definition: string.c:592
static void test_StrFromTimeIntervalA(void)
Definition: string.c:730
static void test_SHUnicodeToUnicode(void)
Definition: string.c:958
static void test_StrToInt64ExA(void)
Definition: string.c:554
static void test_StrToIntA(void)
Definition: string.c:457
static void test_StrRChrA(void)
Definition: string.c:343
static void test_StrRetToBSTR(void)
Definition: string.c:815
static void test_StrToIntExW(void)
Definition: string.c:519
static BOOL is_lang_english(void)
Definition: string.c:209
static void test_StrChrA(void)
Definition: string.c:238
static void test_StrCatChainW(void)
Definition: string.c:1504
static void test_StrRStrI(void)
Definition: string.c:900
static void test_StrStrW(void)
Definition: string.c:1170
static void test_SHAnsiToAnsi(void)
Definition: string.c:934
static void test_StrToIntW(void)
Definition: string.c:471
static void test_StrChrIA(void)
Definition: string.c:289
static void test_StrCpyW(void)
Definition: string.c:406
static void test_StrFormatKBSizeW(void)
Definition: string.c:682
static void test_StrToIntExA(void)
Definition: string.c:487
static void test_StrCmpW(void)
Definition: string.c:776
static void test_StrChrNW(void)
Definition: string.c:435
static void test_StrStrNIW(void)
Definition: string.c:1410
static void test_StrXXX_overflows(void)
Definition: string.c:985
static void test_StrStrA(void)
Definition: string.c:1123
static void test_StrRChrW(void)
Definition: string.c:374
static void test_StrCpyNXW(void)
Definition: string.c:874
static void test_StrCpyNXA(void)
Definition: string.c:855
#define LOCALE_USER_DEFAULT
#define LOCALE_SDECIMAL
Definition: winnls.h:42
#define LOCALE_STHOUSAND
Definition: winnls.h:43
char * LPSTR
Definition: xmlstorage.h:182
char CHAR
Definition: xmlstorage.h:175

◆ strcmpW()

static LONGLONG *static LONGLONG *static int strcmpW ( const WCHAR str1,
const WCHAR str2 
)
static

Definition at line 72 of file string.c.

73{
74 while (*str1 && (*str1 == *str2)) { str1++; str2++; }
75 return *str1 - *str2;
76}

◆ test_SHAnsiToAnsi()

static void test_SHAnsiToAnsi ( void  )
static

Definition at line 934 of file string.c.

935{
936 char dest[8];
937 DWORD dwRet;
938
939 if (!pSHAnsiToAnsi)
940 {
941 win_skip("SHAnsiToAnsi() is not available\n");
942 return;
943 }
944
945 if (pSHAnsiToAnsi == (void *)pStrPBrkW)
946 {
947 win_skip("Ordinal 345 corresponds to StrPBrkW, skipping SHAnsiToAnsi tests\n");
948 return;
949 }
950
951 memset(dest, '\n', sizeof(dest));
952 dwRet = pSHAnsiToAnsi("hello", dest, ARRAY_SIZE(dest));
953 ok(dwRet == 6 && !memcmp(dest, "hello\0\n\n", sizeof(dest)),
954 "SHAnsiToAnsi: expected 6, \"hello\\0\\n\\n\", got %d, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
955 dwRet, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
956}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define ok(value,...)
Definition: atltest.h:57
#define ARRAY_SIZE(A)
Definition: main.h:33
unsigned long DWORD
Definition: ntddk_ex.h:95
static char * dest
Definition: rtl.c:135
#define win_skip
Definition: test.h:163
#define memset(x, y, z)
Definition: compat.h:39

Referenced by START_TEST().

◆ test_SHUnicodeToUnicode()

static void test_SHUnicodeToUnicode ( void  )
static

Definition at line 958 of file string.c.

959{
960 static const WCHAR lpInit[] = { '\n','\n','\n','\n','\n','\n','\n','\n' };
961 static const WCHAR lpSrc[] = { 'h','e','l','l','o','\0' };
962 static const WCHAR lpRes[] = { 'h','e','l','l','o','\0','\n','\n' };
963 WCHAR dest[8];
964 DWORD dwRet;
965
966 if (!pSHUnicodeToUnicode)
967 {
968 win_skip("SHUnicodeToUnicode() is not available\n");
969 return;
970 }
971
972 if (pSHUnicodeToUnicode == (void *)pStrRChrA)
973 {
974 win_skip("Ordinal 346 corresponds to StrRChrA, skipping SHUnicodeToUnicode tests\n");
975 return;
976 }
977
978 memcpy(dest, lpInit, sizeof(lpInit));
979 dwRet = pSHUnicodeToUnicode(lpSrc, dest, ARRAY_SIZE(dest));
980 ok(dwRet == 6 && !memcmp(dest, lpRes, sizeof(dest)),
981 "SHUnicodeToUnicode: expected 6, \"hello\\0\\n\\n\", got %d, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
982 dwRet, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
983}
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878

Referenced by START_TEST().

◆ test_StrCatChainW()

static void test_StrCatChainW ( void  )
static

Definition at line 1504 of file string.c.

1505{
1506 static const WCHAR deadbeefW[] = {'D','e','A','d','B','e','E','f',0};
1507 static const WCHAR deadW[] = {'D','e','A','d',0};
1508 static const WCHAR beefW[] = {'B','e','E','f',0};
1509
1510 WCHAR buf[32 + 1];
1511 DWORD ret;
1512
1513 if (!pStrCatChainW)
1514 {
1515 win_skip("StrCatChainW is not available\n");
1516 return;
1517 }
1518
1519 /* Test with NULL buffer */
1520 ret = pStrCatChainW(NULL, 0, 0, beefW);
1521 ok(ret == 0, "Expected StrCatChainW to return 0, got %u\n", ret);
1522
1523 /* Test with empty buffer */
1524 memset(buf, 0x11, sizeof(buf));
1525 ret = pStrCatChainW(buf, 0, 0, beefW);
1526 ok(ret == 0, "Expected StrCatChainW to return 0, got %u\n", ret);
1527 ok(buf[0] == 0x1111, "Expected buf[0] = 0x1111, got %x\n", buf[0]);
1528
1529 memcpy(buf, deadbeefW, sizeof(deadbeefW));
1530 ret = pStrCatChainW(buf, 0, -1, beefW);
1531 ok(ret == 8, "Expected StrCatChainW to return 8, got %u\n", ret);
1532 ok(!memcmp(buf, deadbeefW, sizeof(deadbeefW)), "Buffer contains wrong data\n");
1533
1534 /* Append data to existing string with offset = -1 */
1535 memset(buf, 0x11, sizeof(buf));
1536 ret = pStrCatChainW(buf, 32, 0, deadW);
1537 ok(ret == 4, "Expected StrCatChainW to return 4, got %u\n", ret);
1538 ok(!memcmp(buf, deadW, sizeof(deadW)), "Buffer contains wrong data\n");
1539
1540 ret = pStrCatChainW(buf, 32, -1, beefW);
1541 ok(ret == 8, "Expected StrCatChainW to return 8, got %u\n", ret);
1542 ok(!memcmp(buf, deadbeefW, sizeof(deadbeefW)), "Buffer contains wrong data\n");
1543
1544 /* Append data at a fixed offset */
1545 memset(buf, 0x11, sizeof(buf));
1546 ret = pStrCatChainW(buf, 32, 0, deadW);
1547 ok(ret == 4, "Expected StrCatChainW to return 4, got %u\n", ret);
1548 ok(!memcmp(buf, deadW, sizeof(deadW)), "Buffer contains wrong data\n");
1549
1550 ret = pStrCatChainW(buf, 32, 4, beefW);
1551 ok(ret == 8, "Expected StrCatChainW to return 8, got %u\n", ret);
1552 ok(!memcmp(buf, deadbeefW, sizeof(deadbeefW)), "Buffer contains wrong data\n");
1553
1554 /* Buffer exactly sufficient for string + terminating null */
1555 memset(buf, 0x11, sizeof(buf));
1556 ret = pStrCatChainW(buf, 5, 0, deadW);
1557 ok(ret == 4, "Expected StrCatChainW to return 4, got %u\n", ret);
1558 ok(!memcmp(buf, deadW, sizeof(deadW)), "Buffer contains wrong data\n");
1559
1560 /* Buffer too small, string will be truncated */
1561 memset(buf, 0x11, sizeof(buf));
1562 ret = pStrCatChainW(buf, 4, 0, deadW);
1563 if (ret == 4)
1564 {
1565 /* Windows 2000 and XP uses a slightly different implementation
1566 * for StrCatChainW, which doesn't ensure that strings are null-
1567 * terminated. Skip test if we detect such an implementation. */
1568 win_skip("Windows2000/XP behaviour detected for StrCatChainW, skipping tests\n");
1569 return;
1570 }
1571 ok(ret == 3, "Expected StrCatChainW to return 3, got %u\n", ret);
1572 ok(!memcmp(buf, deadW, 3 * sizeof(WCHAR)), "Buffer contains wrong data\n");
1573 ok(!buf[3], "String is not nullterminated\n");
1574 ok(buf[4] == 0x1111, "Expected buf[4] = 0x1111, got %x\n", buf[4]);
1575
1576 /* Overwrite part of an existing string */
1577 ret = pStrCatChainW(buf, 4, 1, beefW);
1578 ok(ret == 3, "Expected StrCatChainW to return 3, got %u\n", ret);
1579 ok(buf[0] == 'D', "Expected buf[0] = 'D', got %x\n", buf[0]);
1580 ok(buf[1] == 'B', "Expected buf[1] = 'B', got %x\n", buf[1]);
1581 ok(buf[2] == 'e', "Expected buf[2] = 'e', got %x\n", buf[2]);
1582 ok(!buf[3], "String is not nullterminated\n");
1583 ok(buf[4] == 0x1111, "Expected buf[4] = 0x1111, got %x\n", buf[4]);
1584
1585 /* Test appending to full buffer */
1586 memset(buf, 0x11, sizeof(buf));
1587 memcpy(buf, deadbeefW, sizeof(deadbeefW));
1588 memcpy(buf + 9, deadW, sizeof(deadW));
1589 ret = pStrCatChainW(buf, 9, 8, beefW);
1590 ok(ret == 8, "Expected StrCatChainW to return 8, got %u\n", ret);
1591 ok(!memcmp(buf, deadbeefW, sizeof(deadbeefW)), "Buffer contains wrong data\n");
1592 ok(!memcmp(buf + 9, deadW, sizeof(deadW)), "Buffer contains wrong data\n");
1593
1594 /* Offset points at the end of the buffer */
1595 ret = pStrCatChainW(buf, 9, 9, beefW);
1596 ok(ret == 8, "Expected StrCatChainW to return 8, got %u\n", ret);
1597 ok(!memcmp(buf, deadbeefW, sizeof(deadbeefW)), "Buffer contains wrong data\n");
1598 ok(!memcmp(buf + 9, deadW, sizeof(deadW)), "Buffer contains wrong data\n");
1599
1600 /* Offset points outside of the buffer */
1601 ret = pStrCatChainW(buf, 9, 10, beefW);
1602 ok(ret == 10, "Expected StrCatChainW to return 10, got %u\n", ret);
1603 ok(!memcmp(buf, deadbeefW, sizeof(deadbeefW)), "Buffer contains wrong data\n");
1604 ok(!memcmp(buf + 9, deadW, sizeof(deadW)), "Buffer contains wrong data\n");
1605
1606 /* The same but without nullterminated string */
1607 memcpy(buf, deadbeefW, sizeof(deadbeefW));
1608 ret = pStrCatChainW(buf, 5, -1, deadW);
1609 ok(ret == 8, "Expected StrCatChainW to return 8, got %u\n", ret);
1610 ok(!memcmp(buf, deadbeefW, sizeof(deadbeefW)), "Buffer contains wrong data\n");
1611
1612 ret = pStrCatChainW(buf, 5, 5, deadW);
1613 ok(ret == 4, "Expected StrCatChainW to return 4, got %u\n", ret);
1614 ok(!memcmp(buf, deadW, sizeof(deadW)), "Buffer contains wrong data\n");
1615 ok(buf[5] == 'e', "Expected buf[5] = 'e', got %x\n", buf[5]);
1616
1617 ret = pStrCatChainW(buf, 5, 6, deadW);
1618 ok(ret == 6, "Expected StrCatChainW to return 6, got %u\n", ret);
1619 ok(!memcmp(buf, deadW, sizeof(deadW)), "Buffer contains wrong data\n");
1620 ok(buf[5] == 'e', "Expected buf[5] = 'e', got %x\n", buf[5]);
1621}
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751

Referenced by START_TEST().

◆ test_StrChrA()

static void test_StrChrA ( void  )
static

Definition at line 238 of file string.c.

239{
240 char string[129];
241 WORD count;
242
243 /* this test crashes on win2k SP4 */
244 /*ok(!StrChrA(NULL,'\0'), "found a character in a NULL string!\n");*/
245
246 for (count = 32; count < 128; count++)
247 string[count] = (char)count;
248 string[128] = '\0';
249
250 for (count = 32; count < 128; count++)
251 {
252 LPSTR result = StrChrA(string+32, count);
253 INT pos = result - string;
254 ok(pos == count, "found char '%c' in wrong place: got %d, expected %d\n", count, pos, count);
255 }
256
257 for (count = 32; count < 128; count++)
258 {
259 LPSTR result = StrChrA(string+count+1, count);
260 ok(!result, "found char '%c' not in the string\n", count);
261 }
262}
LPSTR WINAPI StrChrA(LPCSTR lpszStr, WORD ch)
Definition: string.c:270
unsigned short WORD
Definition: ntddk_ex.h:93
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLuint64EXT * result
Definition: glext.h:11304
char string[160]
Definition: util.h:11

Referenced by START_TEST().

◆ test_StrChrIA()

static void test_StrChrIA ( void  )
static

Definition at line 289 of file string.c.

290{
291 char string[129];
292 WORD count;
293
294 /* this test crashes on win2k SP4 */
295 /*ok(!StrChrIA(NULL,'\0'), "found a character in a NULL string!\n");*/
296
297 for (count = 32; count < 128; count++)
298 string[count] = (char)count;
299 string[128] = '\0';
300
301 for (count = 'A'; count <= 'X'; count++)
302 {
303 LPSTR result = StrChrIA(string+32, count);
304
305 ok(result - string == count, "found char '%c' in wrong place\n", count);
306 ok(StrChrIA(result, count)!=NULL, "didn't find lowercase '%c'\n", count);
307 }
308
309 for (count = 'a'; count < 'z'; count++)
310 {
311 LPSTR result = StrChrIA(string+count+1, count);
312 ok(!result, "found char not in the string\n");
313 }
314}
LPSTR WINAPI StrChrIA(LPCSTR lpszStr, WORD ch)
Definition: string.c:614

Referenced by START_TEST().

◆ test_StrChrIW()

static void test_StrChrIW ( void  )
static

Definition at line 316 of file string.c.

317{
318 WCHAR string[129];
319 WORD count;
320
321 /* this test crashes on win2k SP4 */
322 /*ok(!StrChrIA(NULL,'\0'), "found a character in a NULL string!\n");*/
323
324 for (count = 32; count < 128; count++)
325 string[count] = count;
326 string[128] = '\0';
327
328 for (count = 'A'; count <= 'X'; count++)
329 {
330 LPWSTR result = StrChrIW(string+32, count);
331
332 ok(result - string == count, "found char '%c' in wrong place\n", count);
333 ok(StrChrIW(result, count)!=NULL, "didn't find lowercase '%c'\n", count);
334 }
335
336 for (count = 'a'; count < 'z'; count++)
337 {
338 LPWSTR result = StrChrIW(string+count+1, count);
339 ok(!result, "found char not in the string\n");
340 }
341}
LPWSTR WINAPI StrChrIW(LPCWSTR lpszStr, WCHAR ch)
Definition: string.c:635
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by START_TEST().

◆ test_StrChrNW()

static void test_StrChrNW ( void  )
static

Definition at line 435 of file string.c.

436{
437 static const WCHAR string[] = {'T','e','s','t','i','n','g',' ','S','t','r','i','n','g',0};
438 LPWSTR p;
439
440 if (!pStrChrNW)
441 {
442 win_skip("StrChrNW not available\n");
443 return;
444 }
445
446 p = pStrChrNW(string,'t',10);
447 ok(*p=='t',"Found wrong 't'\n");
448 ok(*(p+1)=='i',"next should be 'i'\n");
449
450 p = pStrChrNW(string,'S',10);
451 ok(*p=='S',"Found wrong 'S'\n");
452
453 p = pStrChrNW(string,'r',10);
454 ok(p==NULL,"Should not have found 'r'\n");
455}
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by START_TEST().

◆ test_StrChrW()

static void test_StrChrW ( void  )
static

Definition at line 264 of file string.c.

265{
266 WCHAR string[16385];
267 WORD count;
268
269 /* this test crashes on win2k SP4 */
270 /*ok(!StrChrW(NULL,'\0'), "found a character in a NULL string!\n");*/
271
272 for (count = 32; count < 16384; count++)
273 string[count] = count;
274 string[16384] = '\0';
275
276 for (count = 32; count < 16384; count++)
277 {
278 LPWSTR result = StrChrW(string+32, count);
279 ok((result - string) == count, "found char %d in wrong place\n", count);
280 }
281
282 for (count = 32; count < 16384; count++)
283 {
284 LPWSTR result = StrChrW(string+count+1, count);
285 ok(!result, "found char not in the string\n");
286 }
287}
LPWSTR WINAPI StrChrW(LPCWSTR lpszStr, WCHAR ch)
Definition: string.c:257

Referenced by START_TEST().

◆ test_StrCmpA()

static void test_StrCmpA ( void  )
static

Definition at line 745 of file string.c.

746{
747 static const char str1[] = {'a','b','c','d','e','f'};
748 static const char str2[] = {'a','B','c','d','e','f'};
749 ok(0 != StrCmpNA(str1, str2, 6), "StrCmpNA is case-insensitive\n");
750 ok(0 == StrCmpNIA(str1, str2, 6), "StrCmpNIA is case-sensitive\n");
751 if (pChrCmpIA) {
752 ok(!pChrCmpIA('a', 'a'), "ChrCmpIA doesn't work at all!\n");
753 ok(!pChrCmpIA('b', 'B'), "ChrCmpIA is not case-insensitive\n");
754 ok(pChrCmpIA('a', 'z'), "ChrCmpIA believes that a == z!\n");
755 }
756 else
757 win_skip("ChrCmpIA() is not available\n");
758
759 if (pStrIsIntlEqualA)
760 {
761 ok(pStrIsIntlEqualA(FALSE, str1, str2, 5), "StrIsIntlEqualA(FALSE,...) isn't case-insensitive\n");
762 ok(!pStrIsIntlEqualA(TRUE, str1, str2, 5), "StrIsIntlEqualA(TRUE,...) isn't case-sensitive\n");
763 }
764 else
765 win_skip("StrIsIntlEqualA() is not available\n");
766
767 if (pIntlStrEqWorkerA)
768 {
769 ok(pIntlStrEqWorkerA(FALSE, str1, str2, 5), "IntlStrEqWorkerA(FALSE,...) isn't case-insensitive\n");
770 ok(!pIntlStrEqWorkerA(TRUE, str1, str2, 5), "pIntlStrEqWorkerA(TRUE,...) isn't case-sensitive\n");
771 }
772 else
773 win_skip("IntlStrEqWorkerA() is not available\n");
774}
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
INT WINAPI StrCmpNIA(LPCSTR lpszStr, LPCSTR lpszComp, INT iLen)
Definition: string.c:300
INT WINAPI StrCmpNA(LPCSTR lpszStr, LPCSTR lpszComp, INT iLen)
Definition: string.c:493

Referenced by START_TEST().

◆ test_StrCmpW()

static void test_StrCmpW ( void  )
static

Definition at line 776 of file string.c.

777{
778 static const WCHAR str1[] = {'a','b','c','d','e','f'};
779 static const WCHAR str2[] = {'a','B','c','d','e','f'};
780 ok(0 != StrCmpNW(str1, str2, 5), "StrCmpNW is case-insensitive\n");
781 ok(0 == StrCmpNIW(str1, str2, 5), "StrCmpNIW is case-sensitive\n");
782 if (pChrCmpIW) {
783 ok(!pChrCmpIW('a', 'a'), "ChrCmpIW doesn't work at all!\n");
784 ok(!pChrCmpIW('b', 'B'), "ChrCmpIW is not case-insensitive\n");
785 ok(pChrCmpIW('a', 'z'), "ChrCmpIW believes that a == z!\n");
786 }
787 else
788 win_skip("ChrCmpIW() is not available\n");
789
790 if (pStrIsIntlEqualW)
791 {
792 ok(pStrIsIntlEqualW(FALSE, str1, str2, 5), "StrIsIntlEqualW(FALSE,...) isn't case-insensitive\n");
793 ok(!pStrIsIntlEqualW(TRUE, str1, str2, 5), "StrIsIntlEqualW(TRUE,...) isn't case-sensitive\n");
794 }
795 else
796 win_skip("StrIsIntlEqualW() is not available\n");
797
798 if (pIntlStrEqWorkerW)
799 {
800 ok(pIntlStrEqWorkerW(FALSE, str1, str2, 5), "IntlStrEqWorkerW(FALSE,...) isn't case-insensitive\n");
801 ok(!pIntlStrEqWorkerW(TRUE, str1, str2, 5), "IntlStrEqWorkerW(TRUE,...) isn't case-sensitive\n");
802 }
803 else
804 win_skip("IntlStrEqWorkerW() is not available\n");
805}
INT WINAPI StrCmpNIW(LPCWSTR lpszStr, LPCWSTR lpszComp, INT iLen)
Definition: string.c:311
INT WINAPI StrCmpNW(LPCWSTR lpszStr, LPCWSTR lpszComp, INT iLen)
Definition: string.c:504

Referenced by START_TEST().

◆ test_StrCpyNXA()

static void test_StrCpyNXA ( void  )
static

Definition at line 855 of file string.c.

856{
857 LPCSTR lpSrc = "hello";
858 LPSTR lpszRes;
859 char dest[8];
860
861 if (!pStrCpyNXA)
862 {
863 win_skip("StrCpyNXA() is not available\n");
864 return;
865 }
866
867 memset(dest, '\n', sizeof(dest));
868 lpszRes = pStrCpyNXA(dest, lpSrc, ARRAY_SIZE(dest));
869 ok(lpszRes == dest + 5 && !memcmp(dest, "hello\0\n\n", sizeof(dest)),
870 "StrCpyNXA: expected %p, \"hello\\0\\n\\n\", got %p, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
871 dest + 5, lpszRes, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
872}
const char * LPCSTR
Definition: xmlstorage.h:183

Referenced by START_TEST().

◆ test_StrCpyNXW()

static void test_StrCpyNXW ( void  )
static

Definition at line 874 of file string.c.

875{
876 static const WCHAR lpInit[] = { '\n','\n','\n','\n','\n','\n','\n','\n' };
877 static const WCHAR lpSrc[] = { 'h','e','l','l','o','\0' };
878 static const WCHAR lpRes[] = { 'h','e','l','l','o','\0','\n','\n' };
879 LPWSTR lpszRes;
880 WCHAR dest[8];
881
882 if (!pStrCpyNXW)
883 {
884 win_skip("StrCpyNXW() is not available\n");
885 return;
886 }
887
888 memcpy(dest, lpInit, sizeof(lpInit));
889 lpszRes = pStrCpyNXW(dest, lpSrc, ARRAY_SIZE(dest));
890 ok(lpszRes == dest + 5 && !memcmp(dest, lpRes, sizeof(dest)),
891 "StrCpyNXW: expected %p, \"hello\\0\\n\\n\", got %p, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
892 dest + 5, lpszRes, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
893}

Referenced by START_TEST().

◆ test_StrCpyW()

static void test_StrCpyW ( void  )
static

Definition at line 406 of file string.c.

407{
408 WCHAR szSrc[256];
409 WCHAR szBuff[256];
411 LPWSTR lpRes;
412
413 while(result->value)
414 {
415 MultiByteToWideChar(CP_ACP, 0, result->byte_size_64, -1, szSrc, ARRAY_SIZE(szSrc));
416
417 lpRes = StrCpyW(szBuff, szSrc);
418 ok(!StrCmpW(szSrc, szBuff) && lpRes == szBuff, "Copied string %s wrong\n", result->byte_size_64);
419 result++;
420 }
421
422 /* this test crashes on win2k SP4 */
423 /*lpRes = StrCpyW(szBuff, NULL);*/
424 /*ok(lpRes == szBuff, "Wrong return value: got %p expected %p\n", lpRes, szBuff);*/
425
426 /* this test crashes on win2k SP4 */
427 /*lpRes = StrCpyW(NULL, szSrc);*/
428 /*ok(lpRes == NULL, "Wrong return value: got %p expected NULL\n", lpRes);*/
429
430 /* this test crashes on win2k SP4 */
431 /*lpRes = StrCpyW(NULL, NULL);*/
432 /*ok(lpRes == NULL, "Wrong return value: got %p expected NULL\n", lpRes);*/
433}
int WINAPI StrCmpW(LPCWSTR lpszStr, LPCWSTR lpszComp)
Definition: string.c:434
LPWSTR WINAPI StrCpyW(LPWSTR lpszStr, LPCWSTR lpszSrc)
Definition: string.c:514
static const StrFormatSizeResult StrFormatSize_results[]
Definition: string.c:124

Referenced by START_TEST().

◆ test_StrDupA()

static void test_StrDupA ( void  )
static

Definition at line 633 of file string.c.

634{
635 LPSTR lpszStr;
637
638 while(result->value)
639 {
640 lpszStr = StrDupA(result->byte_size_64);
641
642 ok(lpszStr != NULL, "Dup failed\n");
643 if (lpszStr)
644 {
645 ok(!strcmp(result->byte_size_64, lpszStr), "Copied string wrong\n");
646 LocalFree(lpszStr);
647 }
648 result++;
649 }
650
651 /* Later versions of shlwapi return NULL for this, but earlier versions
652 * returned an empty string (as Wine does).
653 */
654 lpszStr = StrDupA(NULL);
655 ok(lpszStr == NULL || *lpszStr == '\0', "NULL string returned %p\n", lpszStr);
656 LocalFree(lpszStr);
657}
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
LPSTR WINAPI StrDupA(LPCSTR lpszStr)
Definition: string.c:1064
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594

Referenced by START_TEST().

◆ test_StrFormatByteSize64A()

static void test_StrFormatByteSize64A ( void  )
static

Definition at line 659 of file string.c.

660{
661 char szBuff[256];
663
664 if (!pStrFormatByteSize64A)
665 {
666 win_skip("StrFormatByteSize64A() is not available\n");
667 return;
668 }
669
670 while(result->value)
671 {
672 pStrFormatByteSize64A(result->value, szBuff, 256);
673
674 ok(!strcmp(result->byte_size_64, szBuff),
675 "Formatted %s wrong: got %s, expected %s\n",
676 wine_dbgstr_longlong(result->value), szBuff, result->byte_size_64);
677
678 result++;
679 }
680}
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49

Referenced by START_TEST().

◆ test_StrFormatKBSizeA()

static void test_StrFormatKBSizeA ( void  )
static

Definition at line 705 of file string.c.

706{
707 char szBuff[256];
709
710 if (!pStrFormatKBSizeA)
711 {
712 win_skip("StrFormatKBSizeA() is not available\n");
713 return;
714 }
715
716 while(result->value)
717 {
718 pStrFormatKBSizeA(result->value, szBuff, 256);
719
720 /* shlwapi on Win98 SE does not appear to apply delimiters to the output
721 * and does not correctly handle extremely large values. */
722 ok(!strcmp(result->kb_size, szBuff) ||
723 (result->kb_size_broken && !strcmp(result->kb_size2, szBuff)),
724 "Formatted %s wrong: got %s, expected %s\n",
725 wine_dbgstr_longlong(result->value), szBuff, result->kb_size);
726 result++;
727 }
728}

Referenced by START_TEST().

◆ test_StrFormatKBSizeW()

static void test_StrFormatKBSizeW ( void  )
static

Definition at line 682 of file string.c.

683{
684 WCHAR szBuffW[256];
685 char szBuff[256];
687
688 if (!pStrFormatKBSizeW)
689 {
690 win_skip("StrFormatKBSizeW() is not available\n");
691 return;
692 }
693
694 while(result->value)
695 {
696 pStrFormatKBSizeW(result->value, szBuffW, 256);
697 WideCharToMultiByte(CP_ACP, 0, szBuffW, -1, szBuff, ARRAY_SIZE(szBuff), NULL, NULL);
698
699 ok(!strcmp(result->kb_size, szBuff), "Formatted %s wrong: got %s, expected %s\n",
700 wine_dbgstr_longlong(result->value), szBuff, result->kb_size);
701 result++;
702 }
703}
#define WideCharToMultiByte
Definition: compat.h:111

Referenced by START_TEST().

◆ test_StrFromTimeIntervalA()

static void test_StrFromTimeIntervalA ( void  )
static

Definition at line 730 of file string.c.

731{
732 char szBuff[256];
734
735 while(result->ms)
736 {
737 StrFromTimeIntervalA(szBuff, 256, result->ms, result->digits);
738
739 ok(!strcmp(result->time_interval, szBuff), "Formatted %d %d wrong: %s\n",
740 result->ms, result->digits, szBuff);
741 result++;
742 }
743}
INT WINAPI StrFromTimeIntervalA(LPSTR lpszStr, UINT cchMax, DWORD dwMS, int iDigits)
Definition: string.c:2125
static const StrFromTimeIntervalResult StrFromTimeInterval_results[]
Definition: string.c:152

Referenced by START_TEST().

◆ test_StrRChrA()

static void test_StrRChrA ( void  )
static

Definition at line 343 of file string.c.

344{
345 char string[129];
346 WORD count;
347
348 /* this test crashes on win2k SP4 */
349 /*ok(!StrRChrA(NULL, NULL,'\0'), "found a character in a NULL string!\n");*/
350
351 for (count = 32; count < 128; count++)
352 string[count] = (char)count;
353 string[128] = '\0';
354
355 for (count = 32; count < 128; count++)
356 {
357 LPSTR result = StrRChrA(string+32, NULL, count);
358 ok(result - string == count, "found char %d in wrong place\n", count);
359 }
360
361 for (count = 32; count < 128; count++)
362 {
363 LPSTR result = StrRChrA(string+count+1, NULL, count);
364 ok(!result, "found char not in the string\n");
365 }
366
367 for (count = 32; count < 128; count++)
368 {
369 LPSTR result = StrRChrA(string+count+1, string + 127, count);
370 ok(!result, "found char not in the string\n");
371 }
372}
LPSTR WINAPI StrRChrA(LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch)
Definition: string.c:525

Referenced by START_TEST().

◆ test_StrRChrW()

static void test_StrRChrW ( void  )
static

Definition at line 374 of file string.c.

375{
376 WCHAR string[129];
377 WORD count;
378
379 /* this test crashes on win2k SP4 */
380 /*ok(!StrRChrW(NULL, NULL,'\0'), "found a character in a NULL string!\n");*/
381
382 for (count = 32; count < 128; count++)
383 string[count] = count;
384 string[128] = '\0';
385
386 for (count = 32; count < 128; count++)
387 {
388 LPWSTR result = StrRChrW(string+32, NULL, count);
389 INT pos = result - string;
390 ok(pos == count, "found char %d in wrong place: got %d, expected %d\n", count, pos, count);
391 }
392
393 for (count = 32; count < 128; count++)
394 {
395 LPWSTR result = StrRChrW(string+count+1, NULL, count);
396 ok(!result, "found char %d not in the string\n", count);
397 }
398
399 for (count = 32; count < 128; count++)
400 {
401 LPWSTR result = StrRChrW(string+count+1, string + 127, count);
402 ok(!result, "found char %d not in the string\n", count);
403 }
404}
LPWSTR WINAPI StrRChrW(LPCWSTR str, LPCWSTR end, WORD ch)
Definition: string.c:556

Referenced by START_TEST().

◆ test_StrRetToBSTR()

static void test_StrRetToBSTR ( void  )
static

Definition at line 815 of file string.c.

816{
817 static const WCHAR szTestW[] = { 'T','e','s','t','\0' };
818 ITEMIDLIST iidl[10];
819 BSTR bstr;
820 STRRET strret;
821 HRESULT ret;
822
823 if (!pStrRetToBSTR)
824 {
825 win_skip("StrRetToBSTR() is not available\n");
826 return;
827 }
828
829 strret.uType = STRRET_WSTR;
830 U(strret).pOleStr = CoDupStrW("Test");
831 bstr = 0;
832 ret = pStrRetToBSTR(&strret, NULL, &bstr);
833 ok(ret == S_OK && bstr && !strcmpW(bstr, szTestW),
834 "STRRET_WSTR: dup failed, ret=0x%08x, bstr %p\n", ret, bstr);
835 SysFreeString(bstr);
836
837 strret.uType = STRRET_CSTR;
838 lstrcpyA(U(strret).cStr, "Test");
839 ret = pStrRetToBSTR(&strret, NULL, &bstr);
840 ok(ret == S_OK && bstr && !strcmpW(bstr, szTestW),
841 "STRRET_CSTR: dup failed, ret=0x%08x, bstr %p\n", ret, bstr);
842 SysFreeString(bstr);
843
844 strret.uType = STRRET_OFFSET;
845 U(strret).uOffset = 1;
846 strcpy((char*)&iidl, " Test");
847 ret = pStrRetToBSTR(&strret, iidl, &bstr);
848 ok(ret == S_OK && bstr && !strcmpW(bstr, szTestW),
849 "STRRET_OFFSET: dup failed, ret=0x%08x, bstr %p\n", ret, bstr);
850 SysFreeString(bstr);
851
852 /* Native crashes if str is NULL */
853}
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
#define U(x)
Definition: wordpad.c:45
OLECHAR * BSTR
Definition: compat.h:2293
#define S_OK
Definition: intsafe.h:52
LPSTR WINAPI lstrcpyA(LPSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:100
static const ITEMIDLIST *static WCHAR * CoDupStrW(const char *src)
Definition: string.c:37
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:271
#define strcmpW(s1, s2)
Definition: unicode.h:44
@ STRRET_CSTR
Definition: shtypes.idl:87
@ STRRET_OFFSET
Definition: shtypes.idl:86
@ STRRET_WSTR
Definition: shtypes.idl:85
UINT uType
Definition: shtypes.idl:93

Referenced by START_TEST().

◆ test_StrRStrI()

static void test_StrRStrI ( void  )
static

Definition at line 900 of file string.c.

901{
902 static const CHAR szTest[] = "yAxxxxAy";
903 static const CHAR szTest2[] = "ABABABAB";
904 static const WCHAR wszTest[] = {'y','A','x','x','x','x','A','y',0};
905 static const WCHAR wszTest2[] = {'A','B','A','B','A','B','A','B',0};
906
907 static const WCHAR wszPattern1[] = {'A',0};
908 static const WCHAR wszPattern2[] = {'a','X',0};
909 static const WCHAR wszPattern3[] = {'A','y',0};
910 static const WCHAR wszPattern4[] = {'a','b',0};
911 LPWSTR retW;
912 LPSTR retA;
913
914 check_strrstri(A, szTest, 4, "A", szTest+1);
915 check_strrstri(A, szTest, 4, "aX", szTest+1);
916 check_strrstri(A, szTest, 4, "Ay", NULL);
917 check_strrstri(W, wszTest, 4, wszPattern1, wszTest+1);
918 check_strrstri(W, wszTest, 4, wszPattern2, wszTest+1);
919 check_strrstri(W, wszTest, 4, wszPattern3, NULL);
920
921 check_strrstri(A, szTest2, 4, "ab", szTest2+2);
922 check_strrstri(A, szTest2, 3, "ab", szTest2+2);
923 check_strrstri(A, szTest2, 2, "ab", szTest2);
924 check_strrstri(A, szTest2, 1, "ab", szTest2);
925 check_strrstri(A, szTest2, 0, "ab", NULL);
926 check_strrstri(W, wszTest2, 4, wszPattern4, wszTest2+2);
927 check_strrstri(W, wszTest2, 3, wszPattern4, wszTest2+2);
928 check_strrstri(W, wszTest2, 2, wszPattern4, wszTest2);
929 check_strrstri(W, wszTest2, 1, wszPattern4, wszTest2);
930 check_strrstri(W, wszTest2, 0, wszPattern4, NULL);
931
932}
Definition: ehthrow.cxx:93
#define check_strrstri(type, str, pos, needle, exp)
Definition: string.c:895
Definition: polytest.cpp:36

Referenced by START_TEST().

◆ test_StrStrA()

static void test_StrStrA ( void  )
static

Definition at line 1123 of file string.c.

1124{
1125 static const char *deadbeefA = "DeAdBeEf";
1126
1127 const struct
1128 {
1129 const char *search;
1130 const char *expect;
1131 } StrStrA_cases[] =
1132 {
1133 {"", NULL},
1134 {"DeAd", deadbeefA},
1135 {"dead", NULL},
1136 {"AdBe", deadbeefA + 2},
1137 {"adbe", NULL},
1138 {"BeEf", deadbeefA + 4},
1139 {"beef", NULL},
1140 };
1141
1142 LPSTR ret;
1143 int i;
1144
1145 /* Tests crash on Win2k */
1146 if (0)
1147 {
1148 ret = StrStrA(NULL, NULL);
1149 ok(!ret, "Expected StrStrA to return NULL, got %p\n", ret);
1150
1151 ret = StrStrA(NULL, "");
1152 ok(!ret, "Expected StrStrA to return NULL, got %p\n", ret);
1153
1154 ret = StrStrA("", NULL);
1155 ok(!ret, "Expected StrStrA to return NULL, got %p\n", ret);
1156 }
1157
1158 ret = StrStrA("", "");
1159 ok(!ret, "Expected StrStrA to return NULL, got %p\n", ret);
1160
1161 for (i = 0; i < ARRAY_SIZE(StrStrA_cases); i++)
1162 {
1163 ret = StrStrA(deadbeefA, StrStrA_cases[i].search);
1164 ok(ret == StrStrA_cases[i].expect,
1165 "[%d] Expected StrStrA to return %p, got %p\n",
1166 i, StrStrA_cases[i].expect, ret);
1167 }
1168}
#define expect(EXPECTED, GOT)
Definition: SystemMenu.c:483
LPSTR WINAPI StrStrA(LPCSTR lpszStr, LPCSTR lpszSearch)
Definition: string.c:582
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static short search(int val, const short *table, int size)
Definition: msg711.c:255

Referenced by START_TEST().

◆ test_StrStrIA()

static void test_StrStrIA ( void  )
static

Definition at line 1224 of file string.c.

1225{
1226 static const char *deadbeefA = "DeAdBeEf";
1227
1228 const struct
1229 {
1230 const char *search;
1231 const char *expect;
1232 } StrStrIA_cases[] =
1233 {
1234 {"", NULL},
1235 {"DeAd", deadbeefA},
1236 {"dead", deadbeefA},
1237 {"AdBe", deadbeefA + 2},
1238 {"adbe", deadbeefA + 2},
1239 {"BeEf", deadbeefA + 4},
1240 {"beef", deadbeefA + 4},
1241 {"cafe", NULL},
1242 };
1243
1244 LPSTR ret;
1245 int i;
1246
1247 /* Tests crash on Win2k */
1248 if (0)
1249 {
1250 ret = StrStrIA(NULL, NULL);
1251 ok(!ret, "Expected StrStrIA to return NULL, got %p\n", ret);
1252
1253 ret = StrStrIA(NULL, "");
1254 ok(!ret, "Expected StrStrIA to return NULL, got %p\n", ret);
1255
1256 ret = StrStrIA("", NULL);
1257 ok(!ret, "Expected StrStrIA to return NULL, got %p\n", ret);
1258 }
1259
1260 ret = StrStrIA("", "");
1261 ok(!ret, "Expected StrStrIA to return NULL, got %p\n", ret);
1262
1263 for (i = 0; i < ARRAY_SIZE(StrStrIA_cases); i++)
1264 {
1265 ret = StrStrIA(deadbeefA, StrStrIA_cases[i].search);
1266 ok(ret == StrStrIA_cases[i].expect,
1267 "[%d] Expected StrStrIA to return %p, got %p\n",
1268 i, StrStrIA_cases[i].expect, ret);
1269 }
1270}
LPSTR WINAPI StrStrIA(LPCSTR lpszStr, LPCSTR lpszSearch)
Definition: string.c:355

Referenced by START_TEST().

◆ test_StrStrIW()

static void test_StrStrIW ( void  )
static

Definition at line 1272 of file string.c.

1273{
1274 static const WCHAR emptyW[] = {0};
1275 static const WCHAR deadbeefW[] = {'D','e','A','d','B','e','E','f',0};
1276 static const WCHAR deadW[] = {'D','e','A','d',0};
1277 static const WCHAR dead_lowerW[] = {'d','e','a','d',0};
1278 static const WCHAR adbeW[] = {'A','d','B','e',0};
1279 static const WCHAR adbe_lowerW[] = {'a','d','b','e',0};
1280 static const WCHAR beefW[] = {'B','e','E','f',0};
1281 static const WCHAR beef_lowerW[] = {'b','e','e','f',0};
1282 static const WCHAR cafeW[] = {'c','a','f','e',0};
1283
1284 const struct
1285 {
1286 const WCHAR *search;
1287 const WCHAR *expect;
1288 } StrStrIW_cases[] =
1289 {
1290 {emptyW, NULL},
1291 {deadW, deadbeefW},
1292 {dead_lowerW, deadbeefW},
1293 {adbeW, deadbeefW + 2},
1294 {adbe_lowerW, deadbeefW + 2},
1295 {beefW, deadbeefW + 4},
1296 {beef_lowerW, deadbeefW + 4},
1297 {cafeW, NULL},
1298 };
1299
1300 LPWSTR ret;
1301 int i;
1302
1303 /* Tests crash on Win2k */
1304 if (0)
1305 {
1306 ret = StrStrIW(NULL, NULL);
1307 ok(!ret, "Expected StrStrIW to return NULL, got %p\n", ret);
1308
1309 ret = StrStrIW(NULL, emptyW);
1310 ok(!ret, "Expected StrStrIW to return NULL, got %p\n", ret);
1311
1312 ret = StrStrIW(emptyW, NULL);
1313 ok(!ret, "Expected StrStrIW to return NULL, got %p\n", ret);
1314 }
1315
1317 ok(!ret, "Expected StrStrIW to return NULL, got %p\n", ret);
1318
1319 for (i = 0; i < ARRAY_SIZE(StrStrIW_cases); i++)
1320 {
1321 ret = StrStrIW(deadbeefW, StrStrIW_cases[i].search);
1322 ok(ret == StrStrIW_cases[i].expect,
1323 "[%d] Expected StrStrIW to return %p, got %p\n",
1324 i, StrStrIW_cases[i].expect, ret);
1325 }
1326}
LPWSTR WINAPI StrStrIW(LPCWSTR lpszStr, LPCWSTR lpszSearch)
Definition: string.c:384
static const WCHAR emptyW[]
Definition: navigate.c:40

Referenced by START_TEST().

◆ test_StrStrNIW()

static void test_StrStrNIW ( void  )
static

Definition at line 1410 of file string.c.

1411{
1412 static const WCHAR emptyW[] = {0};
1413 static const WCHAR deadbeefW[] = {'D','e','A','d','B','e','E','f',0};
1414 static const WCHAR deadW[] = {'D','e','A','d',0};
1415 static const WCHAR dead_lowerW[] = {'d','e','a','d',0};
1416 static const WCHAR adbeW[] = {'A','d','B','e',0};
1417 static const WCHAR adbe_lowerW[] = {'a','d','b','e',0};
1418 static const WCHAR beefW[] = {'B','e','E','f',0};
1419 static const WCHAR beef_lowerW[] = {'b','e','e','f',0};
1420 static const WCHAR cafeW[] = {'c','a','f','e',0};
1421
1422 const struct
1423 {
1424 const WCHAR *search;
1425 const UINT count;
1426 const WCHAR *expect;
1427 } StrStrNIW_cases[] =
1428 {
1429 {emptyW, ARRAY_SIZE(deadbeefW), NULL},
1430 {deadW, ARRAY_SIZE(deadbeefW), deadbeefW},
1431 {dead_lowerW, ARRAY_SIZE(deadbeefW), deadbeefW},
1432 {adbeW, ARRAY_SIZE(deadbeefW), deadbeefW + 2},
1433 {adbe_lowerW, ARRAY_SIZE(deadbeefW), deadbeefW + 2},
1434 {beefW, ARRAY_SIZE(deadbeefW), deadbeefW + 4},
1435 {beef_lowerW, ARRAY_SIZE(deadbeefW), deadbeefW + 4},
1436 {cafeW, ARRAY_SIZE(deadbeefW), NULL},
1437 {beefW, 0, NULL},
1438 {beefW, 1, NULL},
1439 {beefW, 2, NULL},
1440 {beefW, 3, NULL},
1441 {beefW, 4, NULL},
1442 {beefW, 5, deadbeefW + 4},
1443 {beefW, 6, deadbeefW + 4},
1444 {beefW, 7, deadbeefW + 4},
1445 {beefW, 8, deadbeefW + 4},
1446 {beefW, 9, deadbeefW + 4},
1447 {beef_lowerW, 0, NULL},
1448 {beef_lowerW, 1, NULL},
1449 {beef_lowerW, 2, NULL},
1450 {beef_lowerW, 3, NULL},
1451 {beef_lowerW, 4, NULL},
1452 {beef_lowerW, 5, deadbeefW + 4},
1453 {beef_lowerW, 6, deadbeefW + 4},
1454 {beef_lowerW, 7, deadbeefW + 4},
1455 {beef_lowerW, 8, deadbeefW + 4},
1456 {beef_lowerW, 9, deadbeefW + 4},
1457 };
1458
1459 LPWSTR ret;
1460 UINT i;
1461
1462 if (!pStrStrNIW)
1463 {
1464 win_skip("StrStrNIW() is not available\n");
1465 return;
1466 }
1467
1468 ret = pStrStrNIW(NULL, NULL, 0);
1469 ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1470
1471 ret = pStrStrNIW(NULL, NULL, 10);
1472 ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1473
1474 ret = pStrStrNIW(NULL, emptyW, 10);
1475 ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1476
1477 ret = pStrStrNIW(emptyW, NULL, 10);
1478 ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1479
1480 ret = pStrStrNIW(emptyW, emptyW, 10);
1481 ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1482
1483 for (i = 0; i < ARRAY_SIZE(StrStrNIW_cases); i++)
1484 {
1485 ret = pStrStrNIW(deadbeefW, StrStrNIW_cases[i].search, StrStrNIW_cases[i].count);
1486 ok(ret == StrStrNIW_cases[i].expect,
1487 "[%d] Expected StrStrNIW to return %p, got %p\n",
1488 i, StrStrNIW_cases[i].expect, ret);
1489 }
1490
1491 /* StrStrNIW accepts counts larger than the search string length but rejects
1492 * counts larger than around 2G. The limit seems to change based on the
1493 * caller executable itself. */
1494 ret = pStrStrNIW(deadbeefW, beefW, 100);
1495 ok(ret == deadbeefW + 4, "Expected StrStrNIW to return deadbeefW + 4, got %p\n", ret);
1496
1497 if (0)
1498 {
1499 ret = pStrStrNIW(deadbeefW, beefW, ~0U);
1500 ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1501 }
1502}
unsigned int UINT
Definition: ndis.h:50

Referenced by START_TEST().

◆ test_StrStrNW()

static void test_StrStrNW ( void  )
static

Definition at line 1328 of file string.c.

1329{
1330 static const WCHAR emptyW[] = {0};
1331 static const WCHAR deadbeefW[] = {'D','e','A','d','B','e','E','f',0};
1332 static const WCHAR deadW[] = {'D','e','A','d',0};
1333 static const WCHAR dead_lowerW[] = {'d','e','a','d',0};
1334 static const WCHAR adbeW[] = {'A','d','B','e',0};
1335 static const WCHAR adbe_lowerW[] = {'a','d','b','e',0};
1336 static const WCHAR beefW[] = {'B','e','E','f',0};
1337 static const WCHAR beef_lowerW[] = {'b','e','e','f',0};
1338
1339 const struct
1340 {
1341 const WCHAR *search;
1342 const UINT count;
1343 const WCHAR *expect;
1344 } StrStrNW_cases[] =
1345 {
1346 {emptyW, ARRAY_SIZE(deadbeefW), NULL},
1347 {deadW, ARRAY_SIZE(deadbeefW), deadbeefW},
1348 {dead_lowerW, ARRAY_SIZE(deadbeefW), NULL},
1349 {adbeW, ARRAY_SIZE(deadbeefW), deadbeefW + 2},
1350 {adbe_lowerW, ARRAY_SIZE(deadbeefW), NULL},
1351 {beefW, ARRAY_SIZE(deadbeefW), deadbeefW + 4},
1352 {beef_lowerW, ARRAY_SIZE(deadbeefW), NULL},
1353 {beefW, 0, NULL},
1354 {beefW, 1, NULL},
1355 {beefW, 2, NULL},
1356 {beefW, 3, NULL},
1357 {beefW, 4, NULL},
1358 {beefW, 5, deadbeefW + 4},
1359 {beefW, 6, deadbeefW + 4},
1360 {beefW, 7, deadbeefW + 4},
1361 {beefW, 8, deadbeefW + 4},
1362 {beefW, 9, deadbeefW + 4},
1363 };
1364
1365 LPWSTR ret;
1366 UINT i;
1367
1368 if (!pStrStrNW)
1369 {
1370 win_skip("StrStrNW() is not available\n");
1371 return;
1372 }
1373
1374 ret = pStrStrNW(NULL, NULL, 0);
1375 ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1376
1377 ret = pStrStrNW(NULL, NULL, 10);
1378 ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1379
1380 ret = pStrStrNW(NULL, emptyW, 10);
1381 ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1382
1383 ret = pStrStrNW(emptyW, NULL, 10);
1384 ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1385
1386 ret = pStrStrNW(emptyW, emptyW, 10);
1387 ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1388
1389 for (i = 0; i < ARRAY_SIZE(StrStrNW_cases); i++)
1390 {
1391 ret = pStrStrNW(deadbeefW, StrStrNW_cases[i].search, StrStrNW_cases[i].count);
1392 ok(ret == StrStrNW_cases[i].expect,
1393 "[%d] Expected StrStrNW to return %p, got %p\n",
1394 i, StrStrNW_cases[i].expect, ret);
1395 }
1396
1397 /* StrStrNW accepts counts larger than the search string length but rejects
1398 * counts larger than around 2G. The limit seems to change based on the
1399 * caller executable itself. */
1400 ret = pStrStrNW(deadbeefW, beefW, 100);
1401 ok(ret == deadbeefW + 4, "Expected StrStrNW to return deadbeefW + 4, got %p\n", ret);
1402
1403 if (0)
1404 {
1405 ret = pStrStrNW(deadbeefW, beefW, ~0U);
1406 ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1407 }
1408}

Referenced by START_TEST().

◆ test_StrStrW()

static void test_StrStrW ( void  )
static

Definition at line 1170 of file string.c.

1171{
1172 static const WCHAR emptyW[] = {0};
1173 static const WCHAR deadbeefW[] = {'D','e','A','d','B','e','E','f',0};
1174 static const WCHAR deadW[] = {'D','e','A','d',0};
1175 static const WCHAR dead_lowerW[] = {'d','e','a','d',0};
1176 static const WCHAR adbeW[] = {'A','d','B','e',0};
1177 static const WCHAR adbe_lowerW[] = {'a','d','b','e',0};
1178 static const WCHAR beefW[] = {'B','e','E','f',0};
1179 static const WCHAR beef_lowerW[] = {'b','e','e','f',0};
1180
1181 const struct
1182 {
1183 const WCHAR *search;
1184 const WCHAR *expect;
1185 } StrStrW_cases[] =
1186 {
1187 {emptyW, NULL},
1188 {deadW, deadbeefW},
1189 {dead_lowerW, NULL},
1190 {adbeW, deadbeefW + 2},
1191 {adbe_lowerW, NULL},
1192 {beefW, deadbeefW + 4},
1193 {beef_lowerW, NULL},
1194 };
1195
1196 LPWSTR ret;
1197 int i;
1198
1199 /* Tests crash on Win2k */
1200 if (0)
1201 {
1202 ret = StrStrW(NULL, NULL);
1203 ok(!ret, "Expected StrStrW to return NULL, got %p\n", ret);
1204
1205 ret = StrStrW(NULL, emptyW);
1206 ok(!ret, "Expected StrStrW to return NULL, got %p\n", ret);
1207
1208 ret = StrStrW(emptyW, NULL);
1209 ok(!ret, "Expected StrStrW to return NULL, got %p\n", ret);
1210 }
1211
1213 ok(!ret, "Expected StrStrW to return NULL, got %p\n", ret);
1214
1215 for (i = 0; i < ARRAY_SIZE(StrStrW_cases); i++)
1216 {
1217 ret = StrStrW(deadbeefW, StrStrW_cases[i].search);
1218 ok(ret == StrStrW_cases[i].expect,
1219 "[%d] Expected StrStrW to return %p, got %p\n",
1220 i, StrStrW_cases[i].expect, ret);
1221 }
1222}
LPWSTR WINAPI StrStrW(LPCWSTR lpszStr, LPCWSTR lpszSearch)
Definition: string.c:594

Referenced by START_TEST().

◆ test_StrToInt64ExA()

static void test_StrToInt64ExA ( void  )
static

Definition at line 554 of file string.c.

555{
557 LONGLONG return_val;
558 BOOL bRet;
559
560 if (!pStrToInt64ExA)
561 {
562 win_skip("StrToInt64ExA() is not available\n");
563 return;
564 }
565
566 while (result->string)
567 {
568 return_val = -1;
569 bRet = pStrToInt64ExA(result->string,0,&return_val);
570 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
571 result->string);
572 if (bRet)
573 ok(return_val == result->str_to_int64_ex, "converted '%s' wrong (%s)\n",
574 result->string, wine_dbgstr_longlong(return_val));
575 result++;
576 }
577
579 while (result->string)
580 {
581 return_val = -1;
582 bRet = pStrToInt64ExA(result->string,STIF_SUPPORT_HEX,&return_val);
583 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
584 result->string);
585 if (bRet)
586 ok(return_val == result->str_to_int64_hex, "converted '%s' wrong (%s)\n",
587 result->string, wine_dbgstr_longlong(return_val));
588 result++;
589 }
590}
unsigned int BOOL
Definition: ntddk_ex.h:94
static const StrToIntResult StrToInt_results[]
Definition: string.c:87
#define STIF_SUPPORT_HEX
Definition: shlwapi.h:1452
int64_t LONGLONG
Definition: typedefs.h:68

Referenced by START_TEST().

◆ test_StrToInt64ExW()

static void test_StrToInt64ExW ( void  )
static

Definition at line 592 of file string.c.

593{
594 WCHAR szBuff[256];
596 LONGLONG return_val;
597 BOOL bRet;
598
599 if (!pStrToInt64ExW)
600 {
601 win_skip("StrToInt64ExW() is not available\n");
602 return;
603 }
604
605 while (result->string)
606 {
607 return_val = -1;
608 MultiByteToWideChar(CP_ACP, 0, result->string, -1, szBuff, ARRAY_SIZE(szBuff));
609 bRet = pStrToInt64ExW(szBuff, 0, &return_val);
610 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
611 result->string);
612 if (bRet)
613 ok(return_val == result->str_to_int64_ex, "converted '%s' wrong (%s)\n",
614 result->string, wine_dbgstr_longlong(return_val));
615 result++;
616 }
617
619 while (result->string)
620 {
621 return_val = -1;
622 MultiByteToWideChar(CP_ACP, 0, result->string, -1, szBuff, ARRAY_SIZE(szBuff));
623 bRet = pStrToInt64ExW(szBuff, STIF_SUPPORT_HEX, &return_val);
624 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
625 result->string);
626 if (bRet)
627 ok(return_val == result->str_to_int64_hex, "converted '%s' wrong (%s)\n",
628 result->string, wine_dbgstr_longlong(return_val));
629 result++;
630 }
631}

Referenced by START_TEST().

◆ test_StrToIntA()

static void test_StrToIntA ( void  )
static

Definition at line 457 of file string.c.

458{
460 int return_val;
461
462 while (result->string)
463 {
464 return_val = StrToIntA(result->string);
465 ok(return_val == result->str_to_int, "converted '%s' wrong (%d)\n",
466 result->string, return_val);
467 result++;
468 }
469}
INT WINAPI StrToIntA(LPCSTR lpszStr)
Definition: string.c:374

Referenced by START_TEST().

◆ test_StrToIntExA()

static void test_StrToIntExA ( void  )
static

Definition at line 487 of file string.c.

488{
490 int return_val;
491 BOOL bRet;
492
493 while (result->string)
494 {
495 return_val = -1;
496 bRet = StrToIntExA(result->string,0,&return_val);
497 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
498 result->string);
499 if (bRet)
500 ok(return_val == (int)result->str_to_int64_ex, "converted '%s' wrong (%d)\n",
501 result->string, return_val);
502 result++;
503 }
504
506 while (result->string)
507 {
508 return_val = -1;
509 bRet = StrToIntExA(result->string,STIF_SUPPORT_HEX,&return_val);
510 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
511 result->string);
512 if (bRet)
513 ok(return_val == (int)result->str_to_int64_hex, "converted '%s' wrong (%d)\n",
514 result->string, return_val);
515 result++;
516 }
517}
BOOL WINAPI StrToIntExA(LPCSTR lpszStr, DWORD dwFlags, LPINT lpiRet)
Definition: string.c:886

Referenced by START_TEST().

◆ test_StrToIntExW()

static void test_StrToIntExW ( void  )
static

Definition at line 519 of file string.c.

520{
521 WCHAR szBuff[256];
523 int return_val;
524 BOOL bRet;
525
526 while (result->string)
527 {
528 return_val = -1;
529 MultiByteToWideChar(CP_ACP, 0, result->string, -1, szBuff, ARRAY_SIZE(szBuff));
530 bRet = StrToIntExW(szBuff, 0, &return_val);
531 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
532 result->string);
533 if (bRet)
534 ok(return_val == (int)result->str_to_int64_ex, "converted '%s' wrong (%d)\n",
535 result->string, return_val);
536 result++;
537 }
538
540 while (result->string)
541 {
542 return_val = -1;
543 MultiByteToWideChar(CP_ACP, 0, result->string, -1, szBuff, ARRAY_SIZE(szBuff));
544 bRet = StrToIntExW(szBuff, STIF_SUPPORT_HEX, &return_val);
545 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
546 result->string);
547 if (bRet)
548 ok(return_val == (int)result->str_to_int64_hex, "converted '%s' wrong (%d)\n",
549 result->string, return_val);
550 result++;
551 }
552}
BOOL WINAPI StrToIntExW(LPCWSTR lpszStr, DWORD dwFlags, LPINT lpiRet)
Definition: string.c:970

Referenced by START_TEST().

◆ test_StrToIntW()

static void test_StrToIntW ( void  )
static

Definition at line 471 of file string.c.

472{
473 WCHAR szBuff[256];
475 int return_val;
476
477 while (result->string)
478 {
479 MultiByteToWideChar(CP_ACP, 0, result->string, -1, szBuff, ARRAY_SIZE(szBuff));
480 return_val = StrToIntW(szBuff);
481 ok(return_val == result->str_to_int, "converted '%s' wrong (%d)\n",
482 result->string, return_val);
483 result++;
484 }
485}
INT WINAPI StrToIntW(LPCWSTR lpString)
Definition: string.c:411

Referenced by START_TEST().

◆ test_StrXXX_overflows()

static void test_StrXXX_overflows ( void  )
static

Definition at line 985 of file string.c.

986{
987 CHAR str1[2*MAX_PATH+1], buf[2*MAX_PATH];
988 WCHAR wstr1[2*MAX_PATH+1], wbuf[2*MAX_PATH];
989 const WCHAR fmt[] = {'%','s',0};
990 STRRET strret;
992 int ret;
993 int i;
994
995 for (i=0; i<2*MAX_PATH; i++)
996 {
997 str1[i] = '0'+(i%10);
998 wstr1[i] = '0'+(i%10);
999 }
1000 str1[2*MAX_PATH] = 0;
1001 wstr1[2*MAX_PATH] = 0;
1002
1003 memset(buf, 0xbf, sizeof(buf));
1004 expect_eq(StrCpyNA(buf, str1, 10), buf, PCHAR, "%p");
1005 expect_eq(buf[9], 0, CHAR, "%x");
1006 expect_eq(buf[10], '\xbf', CHAR, "%x");
1007
1008 if (pStrCatBuffA)
1009 {
1010 expect_eq(pStrCatBuffA(buf, str1, 100), buf, PCHAR, "%p");
1011 expect_eq(buf[99], 0, CHAR, "%x");
1012 expect_eq(buf[100], '\xbf', CHAR, "%x");
1013 }
1014 else
1015 win_skip("StrCatBuffA() is not available\n");
1016
1017if (0)
1018{
1019 /* crashes on XP */
1020 StrCpyNW(wbuf, (LPCWSTR)0x1, 10);
1021 StrCpyNW((LPWSTR)0x1, wstr1, 10);
1022}
1023
1024 memset(wbuf, 0xbf, sizeof(wbuf));
1025 expect_eq(StrCpyNW(wbuf, (LPCWSTR)0x1, 1), wbuf, PWCHAR, "%p");
1026 expect_eq(wbuf[0], 0, WCHAR, "%x");
1027 expect_eq(wbuf[1], (WCHAR)0xbfbf, WCHAR, "%x");
1028
1029 memset(wbuf, 0xbf, sizeof(wbuf));
1030 expect_eq(StrCpyNW(wbuf, 0, 10), wbuf, PWCHAR, "%p");
1031 expect_eq(wbuf[0], 0, WCHAR, "%x");
1032 expect_eq(wbuf[1], (WCHAR)0xbfbf, WCHAR, "%x");
1033
1034 memset(wbuf, 0xbf, sizeof(wbuf));
1035 expect_eq(StrCpyNW(wbuf, 0, 0), wbuf, PWCHAR, "%p");
1036 expect_eq(wbuf[0], (WCHAR)0xbfbf, WCHAR, "%x");
1037 expect_eq(wbuf[1], (WCHAR)0xbfbf, WCHAR, "%x");
1038
1039 memset(wbuf, 0xbf, sizeof(wbuf));
1040 expect_eq(StrCpyNW(wbuf, wstr1, 0), wbuf, PWCHAR, "%p");
1041 expect_eq(wbuf[0], (WCHAR)0xbfbf, WCHAR, "%x");
1042 expect_eq(wbuf[1], (WCHAR)0xbfbf, WCHAR, "%x");
1043
1044 memset(wbuf, 0xbf, sizeof(wbuf));
1045 expect_eq(StrCpyNW(wbuf, wstr1, 10), wbuf, PWCHAR, "%p");
1046 expect_eq(wbuf[9], 0, WCHAR, "%x");
1047 expect_eq(wbuf[10], (WCHAR)0xbfbf, WCHAR, "%x");
1048
1049 if (pStrCatBuffW)
1050 {
1051 expect_eq(pStrCatBuffW(wbuf, wstr1, 100), wbuf, PWCHAR, "%p");
1052 expect_eq(wbuf[99], 0, WCHAR, "%x");
1053 expect_eq(wbuf[100], (WCHAR)0xbfbf, WCHAR, "%x");
1054 }
1055 else
1056 win_skip("StrCatBuffW() is not available\n");
1057
1058 if (pStrRetToBufW)
1059 {
1060 memset(wbuf, 0xbf, sizeof(wbuf));
1061 strret.uType = STRRET_WSTR;
1062 U(strret).pOleStr = StrDupW(wstr1);
1063 hres = pStrRetToBufW(&strret, NULL, wbuf, 10);
1064 ok(hres == E_NOT_SUFFICIENT_BUFFER || broken(hres == S_OK) /* winxp */,
1065 "StrRetToBufW returned %08x\n", hres);
1067 expect_eq(wbuf[0], 0, WCHAR, "%x");
1068 expect_eq(wbuf[9], 0, WCHAR, "%x");
1069 expect_eq(wbuf[10], (WCHAR)0xbfbf, WCHAR, "%x");
1070
1071 memset(wbuf, 0xbf, sizeof(wbuf));
1072 strret.uType = STRRET_CSTR;
1073 StrCpyNA(U(strret).cStr, str1, MAX_PATH);
1074 hres = pStrRetToBufW(&strret, NULL, wbuf, 10);
1075 ok(hres == S_OK, "StrRetToBufW returned %08x\n", hres);
1076 ok(!memcmp(wbuf, wstr1, 9*sizeof(WCHAR)) && !wbuf[9], "StrRetToBuf returned %s\n", wine_dbgstr_w(wbuf));
1077
1078 memset(wbuf, 0xbf, sizeof(wbuf));
1079 strret.uType = STRRET_WSTR;
1080 U(strret).pOleStr = NULL;
1081 hres = pStrRetToBufW(&strret, NULL, wbuf, 10);
1082 ok(hres == E_FAIL, "StrRetToBufW returned %08x\n", hres);
1083 ok(!wbuf[0], "StrRetToBuf returned %s\n", wine_dbgstr_w(wbuf));
1084 }
1085 else
1086 win_skip("StrRetToBufW() is not available\n");
1087
1088 if (pStrRetToBufA)
1089 {
1090 memset(buf, 0xbf, sizeof(buf));
1091 strret.uType = STRRET_CSTR;
1092 StrCpyNA(U(strret).cStr, str1, MAX_PATH);
1093 expect_eq2(pStrRetToBufA(&strret, NULL, buf, 10), S_OK, E_NOT_SUFFICIENT_BUFFER /* Vista */, HRESULT, "%x");
1094 expect_eq(buf[9], 0, CHAR, "%x");
1095 expect_eq(buf[10], (CHAR)0xbf, CHAR, "%x");
1096 }
1097 else
1098 win_skip("StrRetToBufA() is not available\n");
1099
1100 if (pwnsprintfA)
1101 {
1102 memset(buf, 0xbf, sizeof(buf));
1103 ret = pwnsprintfA(buf, 10, "%s", str1);
1104 ok(broken(ret == 9) || ret == -1 /* Vista */, "Unexpected wnsprintfA return %d, expected 9 or -1\n", ret);
1105 expect_eq(buf[9], 0, CHAR, "%x");
1106 expect_eq(buf[10], (CHAR)0xbf, CHAR, "%x");
1107 }
1108 else
1109 win_skip("wnsprintfA() is not available\n");
1110
1111 if (pwnsprintfW)
1112 {
1113 memset(wbuf, 0xbf, sizeof(wbuf));
1114 ret = pwnsprintfW(wbuf, 10, fmt, wstr1);
1115 ok(broken(ret == 9) || ret == -1 /* Vista */, "Unexpected wnsprintfW return %d, expected 9 or -1\n", ret);
1116 expect_eq(wbuf[9], 0, WCHAR, "%x");
1117 expect_eq(wbuf[10], (WCHAR)0xbfbf, WCHAR, "%x");
1118 }
1119 else
1120 win_skip("wnsprintfW() is not available\n");
1121}
#define broken(x)
Definition: _sntprintf.h:21
#define E_FAIL
Definition: ddrawi.h:102
#define MAX_PATH
Definition: compat.h:34
LPWSTR WINAPI StrCpyNW(LPWSTR dst, LPCWSTR src, int count)
Definition: string.c:536
LPWSTR WINAPI StrDupW(LPCWSTR lpszStr)
Definition: string.c:1093
#define wine_dbgstr_w
Definition: kernel32.h:34
HRESULT hres
Definition: protocol.c:465
#define expect_eq(expr, value, type, format)
Definition: string.c:52
#define expect_eq2(expr, val1, val2, type, fmt)
Definition: string.c:38
#define StrCpyNA
Definition: shlwapi.h:1514
uint16_t * PWCHAR
Definition: typedefs.h:56
char * PCHAR
Definition: typedefs.h:51
#define E_NOT_SUFFICIENT_BUFFER
Definition: winerror.h:2345
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185

Referenced by START_TEST().

Variable Documentation

◆ CHAR

Definition at line 43 of file string.c.

◆ DWORD

LONGLONG *static DWORD

Definition at line 51 of file string.c.

◆ int

int

Definition at line 45 of file string.c.

◆ INT

static INT

Definition at line 49 of file string.c.

◆ LPCITEMIDLIST

Definition at line 61 of file string.c.

◆ LPCSTR

Definition at line 45 of file string.c.

◆ LPCWSTR

static LPCWSTR

Definition at line 46 of file string.c.

◆ LPSTR

BSTR *static LPSTR

Definition at line 47 of file string.c.

◆ LPWSTR

Definition at line 48 of file string.c.

◆ StrFormatSize_results

const StrFormatSizeResult StrFormatSize_results[]
static
Initial value:
= {
{ -1023, "-1023 bytes", "0 KB"},
{ -24, "-24 bytes", "0 KB"},
{ 309, "309 bytes", "1 KB"},
{ 10191, "9.95 KB", "10 KB"},
{ 100353, "98.0 KB", "99 KB"},
{ 1022286, "998 KB", "999 KB"},
{ 1046862, "0.99 MB", "1,023 KB", 1, "1023 KB"},
{ 1048574619, "999 MB", "1,023,999 KB", 1, "1023999 KB"},
{ 1073741775, "0.99 GB", "1,048,576 KB", 1, "1048576 KB"},
{ ((LONGLONG)0x000000f9 << 32) | 0xfffff94e, "999 GB", "1,048,575,999 KB", 1, "1048575999 KB"},
{ ((LONGLONG)0x000000ff << 32) | 0xfffffa9b, "0.99 TB", "1,073,741,823 KB", 1, "1073741823 KB"},
{ ((LONGLONG)0x0003e7ff << 32) | 0xfffffa9b, "999 TB", "1,073,741,823,999 KB", 1, "4294967295 KB"},
{ ((LONGLONG)0x0003ffff << 32) | 0xfffffbe8, "0.99 PB", "1,099,511,627,775 KB", 1, "4294967295 KB"},
{ ((LONGLONG)0x0f9fffff << 32) | 0xfffffd35, "999 PB", "1,099,511,627,776,000 KB", 1, "0 KB"},
{ ((LONGLONG)0x0fffffff << 32) | 0xfffffa9b, "0.99 EB", "1,125,899,906,842,623 KB", 1, "4294967295 KB"},
{ 0, NULL, NULL }
}

Definition at line 124 of file string.c.

Referenced by test_StrCpyW(), test_StrDupA(), test_StrFormatByteSize64A(), test_StrFormatKBSizeA(), and test_StrFormatKBSizeW().

◆ StrFromTimeInterval_results

const StrFromTimeIntervalResult StrFromTimeInterval_results[]
static

Definition at line 152 of file string.c.

Referenced by test_StrFromTimeIntervalA().

◆ StrToInt_results

const StrToIntResult StrToInt_results[]
static
Initial value:
= {
{ "1099", 1099, 1099, 1099 },
{ "4294967319", 23, ((LONGLONG)1 << 32) | 23, ((LONGLONG)1 << 32) | 23 },
{ "+88987", 0, 88987, 88987 },
{ "012", 12, 12, 12 },
{ "-55", -55, -55, -55 },
{ "-0", 0, 0, 0 },
{ "0x44ff", 0, 0, 0x44ff },
{ "0x2bdc546291f4b1", 0, 0, ((LONGLONG)0x2bdc54 << 32) | 0x6291f4b1 },
{ "+0x44f4", 0, 0, 0x44f4 },
{ "-0x44fd", 0, 0, 0x44fd },
{ "+ 88987", 0, 0, 0 },
{ "- 55", 0, 0, 0 },
{ "- 0", 0, 0, 0 },
{ "+ 0x44f4", 0, 0, 0 },
{ "--0x44fd", 0, 0, 0 },
{ " 1999", 0, 1999, 1999 },
{ " +88987", 0, 88987, 88987 },
{ " 012", 0, 12, 12 },
{ " -55", 0, -55, -55 },
{ " 0x44ff", 0, 0, 0x44ff },
{ " +0x44f4", 0, 0, 0x44f4 },
{ " -0x44fd", 0, 0, 0x44fd },
{ NULL, 0, 0, 0 }
}

Definition at line 87 of file string.c.

Referenced by test_StrToInt64ExA(), test_StrToInt64ExW(), test_StrToIntA(), test_StrToIntExA(), test_StrToIntExW(), and test_StrToIntW().

◆ UINT

static static UINT

Definition at line 54 of file string.c.

◆ WCHAR

static static WCHAR

Definition at line 44 of file string.c.

◆ WORD

Definition at line 60 of file string.c.