Skip to content
Snippets Groups Projects
Commit d3863cfb authored by Jon Griffiths's avatar Jon Griffiths Committed by Alexandre Julliard
Browse files

New tests for shlwapi string and clsid functions.

parent a7b3fd83
No related merge requests found
Makefile Makefile
clist.ok clist.ok
clsid.ok
generated.ok generated.ok
path.ok path.ok
shlwapi_test.exe.spec.c shlwapi_test.exe.spec.c
shreg.ok shreg.ok
string.ok
testlist.c testlist.c
...@@ -7,9 +7,11 @@ IMPORTS = shlwapi advapi32 ...@@ -7,9 +7,11 @@ IMPORTS = shlwapi advapi32
CTESTS = \ CTESTS = \
clist.c \ clist.c \
clsid.c \
generated.c \ generated.c \
path.c \ path.c \
shreg.c shreg.c \
string.c
@MAKE_TEST_RULES@ @MAKE_TEST_RULES@
......
/* Unit test suite for SHLWAPI Class ID functions
*
* Copyright 2003 Jon Griffiths
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdlib.h>
#include <stdio.h>
#define INITGUID
#include "wine/test.h"
#include "winbase.h"
#include "winerror.h"
#include "winnls.h"
#include "winuser.h"
#include "shlguid.h"
#include "shobjidl.h"
#include "wine/debug.h"
#define NO_SHLWAPI_REG
#define NO_SHLWAPI_PATH
#define NO_SHLWAPI_GDI
#define NO_SHLWAPI_STREAM
#include "shlwapi.h"
/* Function ptrs for ordinal calls */
static HMODULE hShlwapi = 0;
static BOOL (WINAPI *pSHLWAPI_269)(LPCSTR, CLSID *) = 0;
static DWORD (WINAPI *pSHLWAPI_23)(REFGUID, LPSTR, INT) = 0;
/* GUIDs to test */
const GUID * TEST_guids[] = {
&CLSID_ShellDesktop,
&CLSID_ShellLink,
&CATID_BrowsableShellExt,
&CATID_BrowseInPlace,
&CATID_DeskBand,
&CATID_InfoBand,
&CATID_CommBand,
&FMTID_Intshcut,
&FMTID_InternetSite,
&CGID_Explorer,
&CGID_ShellDocView,
&CGID_ShellServiceObject,
&CGID_ExplorerBarDoc,
&IID_INewShortcutHookA,
&IID_IShellIcon,
&IID_IShellFolder,
&IID_IShellExtInit,
&IID_IShellPropSheetExt,
&IID_IPersistFolder,
&IID_IExtractIconA,
&IID_IShellDetails,
&IID_IDelayedRelease,
&IID_IShellLinkA,
&IID_IShellCopyHookA,
&IID_IFileViewerA,
&IID_ICommDlgBrowser,
&IID_IEnumIDList,
&IID_IFileViewerSite,
&IID_IContextMenu2,
&IID_IShellExecuteHookA,
&IID_IPropSheetPage,
&IID_INewShortcutHookW,
&IID_IFileViewerW,
&IID_IShellLinkW,
&IID_IExtractIconW,
&IID_IShellExecuteHookW,
&IID_IShellCopyHookW,
&IID_IRemoteComputer,
&IID_IQueryInfo,
&IID_IDockingWindow,
&IID_IDockingWindowSite,
&CLSID_NetworkPlaces,
&CLSID_NetworkDomain,
&CLSID_NetworkServer,
&CLSID_NetworkShare,
&CLSID_MyComputer,
&CLSID_Internet,
&CLSID_ShellFSFolder,
&CLSID_RecycleBin,
&CLSID_ControlPanel,
&CLSID_Printers,
&CLSID_MyDocuments,
NULL
};
static void test_ClassIDs(void)
{
DEFINE_GUID(IID_Endianess, 0x01020304, 0x0506, 0x0708, 0x09, 0x0A, 0x0B,
0x0C, 0x0D, 0x0E, 0x0F, 0x0A);
const GUID **guids = TEST_guids;
char szBuff[256];
GUID guid;
DWORD dwLen;
BOOL bRet;
int i = 0;
if (!pSHLWAPI_269 || !pSHLWAPI_23)
return;
while (*guids)
{
dwLen = pSHLWAPI_23(*guids, szBuff, 256);
ok(dwLen == 39, "wrong size for id %d", i);
bRet = pSHLWAPI_269(szBuff, &guid);
ok(bRet != FALSE, "created invalid string '%s'", szBuff);
if (bRet)
ok(IsEqualGUID(*guids, &guid), "GUID created wrong %d", i);
guids++;
i++;
}
/* Test endianess */
dwLen = pSHLWAPI_23(&IID_Endianess, szBuff, 256);
ok(dwLen == 39, "wrong size for IID_Endianess");
ok(!strcmp(szBuff, "{01020304-0506-0708-090A-0B0C0D0E0F0A}"),
"Endianess Broken, got '%s'", szBuff);
/* test lengths */
szBuff[0] = ':';
dwLen = pSHLWAPI_23(&IID_Endianess, szBuff, 0);
ok(dwLen == 0, "accepted bad length");
ok(szBuff[0] == ':', "wrote to buffer with no length");
szBuff[0] = ':';
dwLen = pSHLWAPI_23(&IID_Endianess, szBuff, 38);
ok(dwLen == 0, "accepted bad length");
ok(szBuff[0] == ':', "wrote to buffer with no length");
szBuff[0] = ':';
dwLen = pSHLWAPI_23(&IID_Endianess, szBuff, 39);
ok(dwLen == 39, "rejected ok length");
ok(szBuff[0] == '{', "Didn't write to buffer with ok length");
/* Test string */
strcpy(szBuff, "{xxx-");
bRet = pSHLWAPI_269(szBuff, &guid);
ok(bRet == FALSE, "accepted invalid string");
dwLen = pSHLWAPI_23(&IID_Endianess, szBuff, 39);
ok(dwLen == 39, "rejected ok length");
ok(szBuff[0] == '{', "Didn't write to buffer with ok length");
}
START_TEST(clsid)
{
hShlwapi = LoadLibraryA("shlwapi.dll");
ok(hShlwapi != 0, "LoadLibraryA failed");
if (hShlwapi)
{
pSHLWAPI_269 = (void*)GetProcAddress(hShlwapi, (LPSTR)269);
pSHLWAPI_23 = (void*)GetProcAddress(hShlwapi, (LPSTR)23);
}
test_ClassIDs();
if (hShlwapi)
FreeLibrary(hShlwapi);
}
/* Unit test suite for SHLWAPI string functions
*
* Copyright 2003 Jon Griffiths
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdlib.h>
#include <stdio.h>
#include "wine/test.h"
#include "winbase.h"
#include "winerror.h"
#include "winnls.h"
#define NO_SHLWAPI_REG
#define NO_SHLWAPI_PATH
#define NO_SHLWAPI_GDI
#define NO_SHLWAPI_STREAM
#include "shlwapi.h"
/* StrToInt/StrToIntEx results */
typedef struct tagStrToIntResult
{
const char* string;
int str_to_int;
int str_to_int_ex;
int str_to_int_hex;
} StrToIntResult;
static const StrToIntResult StrToInt_results[] = {
{ "1099", 1099, 1099, 1099 },
{ "+88987", 0, 88987, 88987 },
{ "012", 12, 12, 12 },
{ "-55", -55, -55, -55 },
{ "-0", 0, 0, 0 },
{ "0x44ff", 0, 0, 0x44ff },
{ "+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 }
};
/* pStrFormatByteSize64/StrFormatKBSize results */
typedef struct tagStrFormatSizeResult
{
LONGLONG value;
const char* byte_size_64;
const char* kb_size;
} StrFormatSizeResult;
static const StrFormatSizeResult StrFormatSize_results[] = {
{ -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"},
{ 1048574619, "999 MB", "1,023,999 KB"},
{ 1073741775, "0.99 GB", "1,048,576 KB"},
{ ((LONGLONG)0x000000f9 << 32) | 0xfffff94e, "999 GB", "1,048,575,999 KB"},
{ ((LONGLONG)0x000000ff << 32) | 0xfffffa9b, "0.99 TB", "1,073,741,823 KB"},
{ ((LONGLONG)0x0003e7ff << 32) | 0xfffffa9b, "999 TB", "1,073,741,823,999 KB"},
{ ((LONGLONG)0x0003ffff << 32) | 0xfffffbe8, "0.99 PB", "1,099,511,627,775 KB"},
{ ((LONGLONG)0x0f9fffff << 32) | 0xfffffd35, "999 PB", "1,099,511,627,776,000 KB"},
{ ((LONGLONG)0x0fffffff << 32) | 0xfffffa9b, "0.99 EB", "1,125,899,906,842,623 KB"},
{ 0, NULL, NULL }
};
/* StrFormatByteSize64/StrFormatKBSize results */
typedef struct tagStrFromTimeIntervalResult
{
DWORD ms;
int digits;
const char* time_interval;
} StrFromTimeIntervalResult;
static const StrFromTimeIntervalResult StrFromTimeInterval_results[] = {
{ 1, 1, " 0 sec" },
{ 1, 2, " 0 sec" },
{ 1, 3, " 0 sec" },
{ 1, 4, " 0 sec" },
{ 1, 5, " 0 sec" },
{ 1, 6, " 0 sec" },
{ 1, 7, " 0 sec" },
{ 1000000, 1, " 10 min" },
{ 1000000, 2, " 16 min" },
{ 1000000, 3, " 16 min 40 sec" },
{ 1000000, 4, " 16 min 40 sec" },
{ 1000000, 5, " 16 min 40 sec" },
{ 1000000, 6, " 16 min 40 sec" },
{ 1000000, 7, " 16 min 40 sec" },
{ 1999999, 1, " 30 min" },
{ 1999999, 2, " 33 min" },
{ 1999999, 3, " 33 min 20 sec" },
{ 1999999, 4, " 33 min 20 sec" },
{ 1999999, 5, " 33 min 20 sec" },
{ 1999999, 6, " 33 min 20 sec" },
{ 1999999, 7, " 33 min 20 sec" },
{ 3999997, 1, " 1 hr" },
{ 3999997, 2, " 1 hr 6 min" },
{ 3999997, 3, " 1 hr 6 min 40 sec" },
{ 3999997, 4, " 1 hr 6 min 40 sec" },
{ 3999997, 5, " 1 hr 6 min 40 sec" },
{ 3999997, 6, " 1 hr 6 min 40 sec" },
{ 3999997, 7, " 1 hr 6 min 40 sec" },
{ 149999851, 7, " 41 hr 40 min 0 sec" },
{ 150999850, 1, " 40 hr" },
{ 150999850, 2, " 41 hr" },
{ 150999850, 3, " 41 hr 50 min" },
{ 150999850, 4, " 41 hr 56 min" },
{ 150999850, 5, " 41 hr 56 min 40 sec" },
{ 150999850, 6, " 41 hr 56 min 40 sec" },
{ 150999850, 7, " 41 hr 56 min 40 sec" },
{ 493999507, 1, " 100 hr" },
{ 493999507, 2, " 130 hr" },
{ 493999507, 3, " 137 hr" },
{ 493999507, 4, " 137 hr 10 min" },
{ 493999507, 5, " 137 hr 13 min" },
{ 493999507, 6, " 137 hr 13 min 20 sec" },
{ 493999507, 7, " 137 hr 13 min 20 sec" },
{ 0, 0, NULL }
};
static void test_StrChrA(void)
{
char string[129];
int count;
ok(!StrChrA(NULL,'\0'), "found a character in a NULL string!");
for (count = 32; count < 128; count++)
string[count] = count;
string[128] = '\0';
for (count = 32; count < 128; count++)
{
LPSTR result = StrChrA(string+32, count);
ok(result - string == count, "found char %d in wrong place", count);
}
for (count = 32; count < 128; count++)
{
LPSTR result = StrChrA(string+count+1, count);
ok(!result, "found char not in the string");
}
}
static void test_StrChrW(void)
{
WCHAR string[16385];
int count;
ok(!StrChrW(NULL,'\0'), "found a character in a NULL string!");
for (count = 32; count < 16384; count++)
string[count] = count;
string[16384] = '\0';
for (count = 32; count < 16384; count++)
{
LPWSTR result = StrChrW(string+32, count);
ok((result - string) == count, "found char %d in wrong place", count);
}
for (count = 32; count < 16384; count++)
{
LPWSTR result = StrChrW(string+count+1, count);
ok(!result, "found char not in the string");
}
}
static void test_StrChrIA(void)
{
char string[129];
int count;
ok(!StrChrIA(NULL,'\0'), "found a character in a NULL string!");
for (count = 32; count < 128; count++)
string[count] = count;
string[128] = '\0';
for (count = 'A'; count <= 'X'; count++)
{
LPSTR result = StrChrIA(string+32, count);
ok(result - string == count, "found char '%c' in wrong place", count);
ok(StrChrIA(result, count)!=NULL, "didn't find lowercase '%c'", count);
}
for (count = 'a'; count < 'z'; count++)
{
LPSTR result = StrChrIA(string+count+1, count);
ok(!result, "found char not in the string");
}
}
static void test_StrChrIW(void)
{
WCHAR string[129];
int count;
ok(!StrChrIA(NULL,'\0'), "found a character in a NULL string!");
for (count = 32; count < 128; count++)
string[count] = count;
string[128] = '\0';
for (count = 'A'; count <= 'X'; count++)
{
LPWSTR result = StrChrIW(string+32, count);
ok(result - string == count, "found char '%c' in wrong place", count);
ok(StrChrIW(result, count)!=NULL, "didn't find lowercase '%c'", count);
}
for (count = 'a'; count < 'z'; count++)
{
LPWSTR result = StrChrIW(string+count+1, count);
ok(!result, "found char not in the string");
}
}
static void test_StrRChrA(void)
{
char string[129];
int count;
ok(!StrRChrA(NULL, NULL,'\0'), "found a character in a NULL string!");
for (count = 32; count < 128; count++)
string[count] = count;
string[128] = '\0';
for (count = 32; count < 128; count++)
{
LPSTR result = StrRChrA(string+32, NULL, count);
ok(result - string == count, "found char %d in wrong place", count);
}
for (count = 32; count < 128; count++)
{
LPSTR result = StrRChrA(string+count+1, NULL, count);
ok(!result, "found char not in the string");
}
for (count = 32; count < 128; count++)
{
LPSTR result = StrRChrA(string+count+1, string + 127, count);
ok(!result, "found char not in the string");
}
}
static void test_StrRChrW(void)
{
WCHAR string[16385];
int count;
ok(!StrRChrW(NULL, NULL,'\0'), "found a character in a NULL string!");
for (count = 32; count < 16384; count++)
string[count] = count;
string[16384] = '\0';
for (count = 32; count < 16384; count++)
{
LPWSTR result = StrRChrW(string+32, NULL, count);
ok(result - string == count, "found char %d in wrong place", count);
}
for (count = 32; count < 16384; count++)
{
LPWSTR result = StrRChrW(string+count+1, NULL, count);
ok(!result, "found char not in the string");
}
for (count = 32; count < 16384; count++)
{
LPWSTR result = StrRChrW(string+count+1, string + 127, count);
ok(!result, "found char not in the string");
}
}
static void test_StrCpyW(void)
{
WCHAR szSrc[256];
WCHAR szBuff[256];
const StrFormatSizeResult* result = StrFormatSize_results;
while(result->value)
{
MultiByteToWideChar(0,0,result->byte_size_64,-1,szSrc,sizeof(szSrc)/sizeof(WCHAR));
StrCpyW(szBuff, szSrc);
ok(!StrCmpW(szSrc, szBuff), "Copied string %s wrong", result->byte_size_64);
result++;
}
}
static void test_StrToIntA(void)
{
const StrToIntResult *result = StrToInt_results;
int return_val;
while (result->string)
{
return_val = StrToIntA(result->string);
ok(return_val == result->str_to_int, "converted '%s' wrong (%d)",
result->string, return_val);
result++;
}
}
static void test_StrToIntW(void)
{
WCHAR szBuff[256];
const StrToIntResult *result = StrToInt_results;
int return_val;
while (result->string)
{
MultiByteToWideChar(0,0,result->string,-1,szBuff,sizeof(szBuff)/sizeof(WCHAR));
return_val = StrToIntW(szBuff);
ok(return_val == result->str_to_int, "converted '%s' wrong (%d)",
result->string, return_val);
result++;
}
}
static void test_StrToIntExA(void)
{
const StrToIntResult *result = StrToInt_results;
int return_val;
BOOL bRet;
while (result->string)
{
return_val = -1;
bRet = StrToIntExA(result->string,0,&return_val);
ok(!bRet || return_val != -1, "No result returned from '%s'",
result->string);
if (bRet)
ok(return_val == result->str_to_int_ex, "converted '%s' wrong (%d)",
result->string, return_val);
result++;
}
result = StrToInt_results;
while (result->string)
{
return_val = -1;
bRet = StrToIntExA(result->string,STIF_SUPPORT_HEX,&return_val);
ok(!bRet || return_val != -1, "No result returned from '%s'",
result->string);
if (bRet)
ok(return_val == result->str_to_int_hex, "converted '%s' wrong (%d)",
result->string, return_val);
result++;
}
}
static void test_StrToIntExW(void)
{
WCHAR szBuff[256];
const StrToIntResult *result = StrToInt_results;
int return_val;
BOOL bRet;
while (result->string)
{
return_val = -1;
MultiByteToWideChar(0,0,result->string,-1,szBuff,sizeof(szBuff)/sizeof(WCHAR));
bRet = StrToIntExW(szBuff, 0, &return_val);
ok(!bRet || return_val != -1, "No result returned from '%s'",
result->string);
if (bRet)
ok(return_val == result->str_to_int_ex, "converted '%s' wrong (%d)",
result->string, return_val);
result++;
}
result = StrToInt_results;
while (result->string)
{
return_val = -1;
MultiByteToWideChar(0,0,result->string,-1,szBuff,sizeof(szBuff)/sizeof(WCHAR));
bRet = StrToIntExW(szBuff, STIF_SUPPORT_HEX, &return_val);
ok(!bRet || return_val != -1, "No result returned from '%s'",
result->string);
if (bRet)
ok(return_val == result->str_to_int_hex, "converted '%s' wrong (%d)",
result->string, return_val);
result++;
}
}
static void test_StrDupA()
{
LPSTR lpszStr;
const StrFormatSizeResult* result = StrFormatSize_results;
while(result->value)
{
lpszStr = StrDupA(result->byte_size_64);
ok(lpszStr != NULL, "Dup failed");
if (lpszStr)
{
ok(!strcmp(result->byte_size_64, lpszStr), "Copied string wrong");
LocalFree((HLOCAL)lpszStr);
}
result++;
}
/* Later versions of shlwapi return NULL for this, but earlier versions
* returned an empty string (as Wine does).
*/
lpszStr = StrDupA(NULL);
ok(lpszStr == NULL || *lpszStr == '\0', "NULL string returned %p", lpszStr);
}
static void test_StrFormatByteSize64A(void)
{
char szBuff[256];
const StrFormatSizeResult* result = StrFormatSize_results;
while(result->value)
{
StrFormatByteSize64A(result->value, szBuff, 256);
ok(!strcmp(result->byte_size_64, szBuff), "Formatted %lld wrong", result->value);
result++;
}
}
static void test_StrFormatKBSizeW(void)
{
/* FIXME: Awaiting NLS fixes in kernel before these succeed */
#if 0
WCHAR szBuffW[256];
char szBuff[256];
const StrFormatSizeResult* result = StrFormatSize_results;
while(result->value)
{
StrFormatKBSizeW(result->value, szBuffW, 256);
WideCharToMultiByte(0,0,szBuffW,-1,szBuff,sizeof(szBuff)/sizeof(WCHAR),0,0);
ok(!strcmp(result->kb_size, szBuff), "Formatted %lld wrong",
result->value);
result++;
}
#endif
}
static void test_StrFormatKBSizeA(void)
{
#if 0
char szBuff[256];
const StrFormatSizeResult* result = StrFormatSize_results;
while(result->value)
{
StrFormatKBSizeA(result->value, szBuff, 256);
ok(!strcmp(result->kb_size, szBuff), "Formatted %lld wrong",
result->value);
result++;
}
#endif
}
void test_StrFromTimeIntervalA(void)
{
char szBuff[256];
const StrFromTimeIntervalResult* result = StrFromTimeInterval_results;
while(result->ms)
{
StrFromTimeIntervalA(szBuff, 256, result->ms, result->digits);
ok(!strcmp(result->time_interval, szBuff), "Formatted %ld %d wrong",
result->ms, result->digits);
result++;
}
}
START_TEST(string)
{
test_StrChrA();
test_StrChrW();
test_StrChrIA();
test_StrChrIW();
test_StrRChrA();
test_StrRChrW();
test_StrCpyW();
test_StrToIntA();
test_StrToIntW();
test_StrToIntExA();
test_StrToIntExW();
test_StrDupA();
test_StrFormatByteSize64A();
test_StrFormatKBSizeA();
test_StrFormatKBSizeW();
test_StrFromTimeIntervalA();
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment