Sweden-Number/dlls/shlwapi/tests/shreg.c

398 lines
13 KiB
C
Raw Normal View History

2002-06-01 01:06:46 +02:00
/* Unit test suite for SHReg* functions
2002-05-09 21:48:07 +02:00
*
* Copyright 2002 Juergen Schmied
*
* 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
2002-05-09 21:48:07 +02:00
*/
#include <assert.h>
#include <stdarg.h>
2002-05-09 21:48:07 +02:00
#include <stdio.h>
#include "wine/test.h"
#include "windef.h"
2002-05-09 21:48:07 +02:00
#include "winbase.h"
#include "winerror.h"
2002-05-09 21:48:07 +02:00
#include "winreg.h"
#include "winuser.h"
#include "shlwapi.h"
2002-09-12 22:45:22 +02:00
/* Keys used for testing */
#define REG_TEST_KEY "Software\\Wine\\Test"
#define REG_CURRENT_VERSION "Software\\Microsoft\\Windows\\CurrentVersion\\explorer"
static HMODULE hshlwapi;
typedef DWORD (WINAPI *SHCopyKeyA_func)(HKEY,LPCSTR,HKEY,DWORD);
static SHCopyKeyA_func pSHCopyKeyA;
typedef DWORD (WINAPI *SHRegGetPathA_func)(HKEY,LPCSTR,LPCSTR,LPSTR,DWORD);
static SHRegGetPathA_func pSHRegGetPathA;
2006-10-10 14:27:58 +02:00
static char sTestpath1[] = "%LONGSYSTEMVAR%\\subdir1";
static char sTestpath2[] = "%FOO%\\subdir1";
2002-05-09 21:48:07 +02:00
static const char * sEnvvar1 = "bar";
static const char * sEnvvar2 = "ImARatherLongButIndeedNeededString";
2002-05-09 21:48:07 +02:00
static char sExpTestpath1[MAX_PATH];
static char sExpTestpath2[MAX_PATH];
static DWORD nExpLen1;
static DWORD nExpLen2;
2002-05-09 21:48:07 +02:00
static const char * sEmptyBuffer ="0123456789";
2002-05-09 21:48:07 +02:00
2002-09-13 00:29:58 +02:00
/* delete key and all its subkeys */
static DWORD delete_key( HKEY hkey, LPCSTR parent, LPCSTR keyname )
2002-09-13 00:29:58 +02:00
{
HKEY parentKey;
2002-09-13 00:29:58 +02:00
DWORD ret;
RegCloseKey(hkey);
/* open the parent of the key to close */
ret = RegOpenKeyExA( HKEY_CURRENT_USER, parent, 0, KEY_ALL_ACCESS, &parentKey);
if (ret != ERROR_SUCCESS)
return ret;
ret = SHDeleteKeyA( parentKey, keyname );
RegCloseKey(parentKey);
return ret;
2002-09-13 00:29:58 +02:00
}
static HKEY create_test_entries(void)
2002-05-09 21:48:07 +02:00
{
HKEY hKey;
DWORD ret;
DWORD nExpectedLen1, nExpectedLen2;
2002-05-09 21:48:07 +02:00
SetEnvironmentVariableA("LONGSYSTEMVAR", sEnvvar1);
SetEnvironmentVariableA("FOO", sEnvvar2);
ret = RegCreateKeyA(HKEY_CURRENT_USER, REG_TEST_KEY, &hKey);
ok( ERROR_SUCCESS == ret, "RegCreateKeyA failed, ret=%u\n", ret);
2002-05-09 21:48:07 +02:00
if (hKey)
{
2005-07-29 16:15:31 +02:00
ok(!RegSetValueExA(hKey,"Test1",0,REG_EXPAND_SZ, (LPBYTE) sTestpath1, strlen(sTestpath1)+1), "RegSetValueExA failed\n");
ok(!RegSetValueExA(hKey,"Test2",0,REG_SZ, (LPBYTE) sTestpath1, strlen(sTestpath1)+1), "RegSetValueExA failed\n");
ok(!RegSetValueExA(hKey,"Test3",0,REG_EXPAND_SZ, (LPBYTE) sTestpath2, strlen(sTestpath2)+1), "RegSetValueExA failed\n");
2002-05-09 21:48:07 +02:00
}
nExpLen1 = ExpandEnvironmentStringsA(sTestpath1, sExpTestpath1, sizeof(sExpTestpath1));
nExpLen2 = ExpandEnvironmentStringsA(sTestpath2, sExpTestpath2, sizeof(sExpTestpath2));
nExpectedLen1 = strlen(sTestpath1) - strlen("%LONGSYSTEMVAR%") + strlen(sEnvvar1) + 1;
nExpectedLen2 = strlen(sTestpath2) - strlen("%FOO%") + strlen(sEnvvar2) + 1;
/* ExpandEnvironmentStringsA on NT4 returns 2x the correct result */
trace("sExplen1 = (%d)\n", nExpLen1);
if (nExpectedLen1 != nExpLen1)
trace( "Expanding %s failed (expected %d) - known bug in NT4\n", sTestpath1, nExpectedLen1 );
2005-02-03 20:38:58 +01:00
trace("sExplen2 = (%d)\n", nExpLen2);
if (nExpectedLen2 != nExpLen2)
trace( "Expanding %s failed (expected %d) - known bug in NT4\n", sTestpath2, nExpectedLen2 );
/* Make sure we carry on with correct values */
nExpLen1 = nExpectedLen1;
nExpLen2 = nExpectedLen2;
return hKey;
2002-05-09 21:48:07 +02:00
}
static void test_SHGetValue(void)
{
DWORD dwSize;
DWORD dwType;
DWORD dwRet;
2002-05-09 21:48:07 +02:00
char buf[MAX_PATH];
strcpy(buf, sEmptyBuffer);
dwSize = MAX_PATH;
dwType = -1;
dwRet = SHGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test1", &dwType, buf, &dwSize);
ok( ERROR_SUCCESS == dwRet, "SHGetValueA failed, ret=%u\n", dwRet);
ok( 0 == strcmp(sExpTestpath1, buf), "Comparing of (%s) with (%s) failed\n", buf, sExpTestpath1);
ok( REG_SZ == dwType, "Expected REG_SZ, got (%u)\n", dwType);
2002-05-09 21:48:07 +02:00
strcpy(buf, sEmptyBuffer);
dwSize = MAX_PATH;
dwType = -1;
dwRet = SHGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test2", &dwType, buf, &dwSize);
ok( ERROR_SUCCESS == dwRet, "SHGetValueA failed, ret=%u\n", dwRet);
ok( 0 == strcmp(sTestpath1, buf) , "Comparing of (%s) with (%s) failed\n", buf, sTestpath1);
ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType);
2002-05-09 21:48:07 +02:00
}
static void test_SHGetRegPath(void)
2002-05-09 21:48:07 +02:00
{
char buf[MAX_PATH];
DWORD dwRet;
2002-05-09 21:48:07 +02:00
if (!pSHRegGetPathA)
return;
2002-05-09 21:48:07 +02:00
strcpy(buf, sEmptyBuffer);
dwRet = (*pSHRegGetPathA)(HKEY_CURRENT_USER, REG_TEST_KEY, "Test1", buf, 0);
ok( ERROR_SUCCESS == dwRet, "SHRegGetPathA failed, ret=%u\n", dwRet);
ok( 0 == strcmp(sExpTestpath1, buf) , "Comparing (%s) with (%s) failed\n", buf, sExpTestpath1);
2002-05-09 21:48:07 +02:00
}
static void test_SHQUeryValueEx(void)
{
HKEY hKey;
DWORD dwSize;
DWORD dwType;
char buf[MAX_PATH];
DWORD dwRet;
const char * sTestedFunction = "";
2002-12-18 21:50:49 +01:00
DWORD nUsedBuffer1,nUsedBuffer2;
2002-05-09 21:48:07 +02:00
sTestedFunction = "RegOpenKeyExA";
dwRet = RegOpenKeyExA(HKEY_CURRENT_USER, REG_TEST_KEY, 0, KEY_QUERY_VALUE, &hKey);
ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet);
2002-05-09 21:48:07 +02:00
/****** SHQueryValueExA ******/
sTestedFunction = "SHQueryValueExA";
nUsedBuffer1 = max(strlen(sExpTestpath1)+1, strlen(sTestpath1)+1);
nUsedBuffer2 = max(strlen(sExpTestpath2)+1, strlen(sTestpath2)+1);
2002-05-09 21:48:07 +02:00
/*
* Case 1.1 All arguments are NULL
*/
dwRet = SHQueryValueExA( hKey, "Test1", NULL, NULL, NULL, NULL);
ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet);
2002-05-09 21:48:07 +02:00
/*
* Case 1.2 dwType is set
*/
dwType = -1;
dwRet = SHQueryValueExA( hKey, "Test1", NULL, &dwType, NULL, NULL);
ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet);
ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType);
2002-05-09 21:48:07 +02:00
/*
* dwSize is set
* dwExpanded < dwUnExpanded
*/
dwSize = 6;
dwRet = SHQueryValueExA( hKey, "Test1", NULL, NULL, NULL, &dwSize);
ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet);
ok( dwSize == nUsedBuffer1, "Buffer sizes (%u) and (%u) are not equal\n", dwSize, nUsedBuffer1);
2002-05-09 21:48:07 +02:00
/*
* dwExpanded > dwUnExpanded
*/
dwSize = 6;
dwRet = SHQueryValueExA( hKey, "Test3", NULL, NULL, NULL, &dwSize);
ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet);
ok( dwSize >= nUsedBuffer2, "Buffer size (%u) should be >= (%u)\n", dwSize, nUsedBuffer2);
2002-05-09 21:48:07 +02:00
/*
* Case 1 string shrinks during expanding
*/
strcpy(buf, sEmptyBuffer);
dwSize = 6;
dwType = -1;
dwRet = SHQueryValueExA( hKey, "Test1", NULL, &dwType, buf, &dwSize);
ok( ERROR_MORE_DATA == dwRet, "Expected ERROR_MORE_DATA, got (%u)\n", dwRet);
ok( 0 == strcmp(sEmptyBuffer, buf) , "Comparing (%s) with (%s) failed\n", buf, sEmptyBuffer);
ok( dwSize == nUsedBuffer1, "Buffer sizes (%u) and (%u) are not equal\n", dwSize, nUsedBuffer1);
ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType);
2002-05-09 21:48:07 +02:00
/*
* string grows during expanding
2007-06-07 11:48:55 +02:00
* dwSize is smaller than the size of the unexpanded string
2002-06-01 01:06:46 +02:00
*/
2002-05-09 21:48:07 +02:00
strcpy(buf, sEmptyBuffer);
dwSize = 6;
dwType = -1;
dwRet = SHQueryValueExA( hKey, "Test3", NULL, &dwType, buf, &dwSize);
ok( ERROR_MORE_DATA == dwRet, "Expected ERROR_MORE_DATA, got (%u)\n", dwRet);
ok( 0 == strcmp(sEmptyBuffer, buf) , "Comparing (%s) with (%s) failed\n", buf, sEmptyBuffer);
ok( dwSize >= nUsedBuffer2, "Buffer size (%u) should be >= (%u)\n", dwSize, nUsedBuffer2);
ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType);
2002-05-09 21:48:07 +02:00
/*
* string grows during expanding
2007-06-07 11:48:55 +02:00
* dwSize is larger than the size of the unexpanded string, but
* smaller than the part before the backslash. If the unexpanded
* string fits into the buffer, it can get cut when expanded.
*/
strcpy(buf, sEmptyBuffer);
dwSize = strlen(sEnvvar2) - 2;
dwType = -1;
dwRet = SHQueryValueExA( hKey, "Test3", NULL, &dwType, buf, &dwSize);
ok( ERROR_MORE_DATA == dwRet, "Expected ERROR_MORE_DATA, got (%u)\n", dwRet);
todo_wine
{
ok( (0 == strcmp("", buf)) || (0 == strcmp(sTestpath2, buf)),
"Expected empty or unexpanded string (win98), got (%s)\n", buf);
}
ok( dwSize >= nUsedBuffer2, "Buffer size (%u) should be >= (%u)\n", dwSize, nUsedBuffer2);
ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType);
2002-05-09 21:48:07 +02:00
/*
* string grows during expanding
2007-06-07 11:48:55 +02:00
* dwSize is larger than the size of the part before the backslash,
* but smaller than the expanded string. If the unexpanded string fits
* into the buffer, it can get cut when expanded.
2002-05-09 21:48:07 +02:00
*/
strcpy(buf, sEmptyBuffer);
dwSize = nExpLen2 - 4;
2002-05-09 21:48:07 +02:00
dwType = -1;
dwRet = SHQueryValueExA( hKey, "Test3", NULL, &dwType, buf, &dwSize);
ok( ERROR_MORE_DATA == dwRet, "Expected ERROR_MORE_DATA, got (%u)\n", dwRet);
todo_wine
{
ok( (0 == strcmp("", buf)) || (0 == strcmp(sEnvvar2, buf)),
2005-03-22 19:18:14 +01:00
"Expected empty or first part of the string \"%s\", got \"%s\"\n", sEnvvar2, buf);
}
ok( dwSize >= nUsedBuffer2, "Buffer size (%u) should be >= (%u)\n", dwSize, nUsedBuffer2);
ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType);
2002-05-09 21:48:07 +02:00
/*
* The buffer is NULL but the size is set
*/
strcpy(buf, sEmptyBuffer);
dwSize = 6;
dwType = -1;
dwRet = SHQueryValueExA( hKey, "Test3", NULL, &dwType, NULL, &dwSize);
ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet);
ok( dwSize >= nUsedBuffer2, "Buffer size (%u) should be >= (%u)\n", dwSize, nUsedBuffer2);
ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType);
2002-05-09 21:48:07 +02:00
RegCloseKey(hKey);
}
static void test_SHCopyKey(void)
{
HKEY hKeySrc, hKeyDst;
2005-02-03 20:38:58 +01:00
DWORD dwRet;
if (!pSHCopyKeyA)
{
win_skip("SHCopyKeyA is not available\n");
return;
}
2002-09-12 22:45:22 +02:00
/* Delete existing destination sub keys */
2002-12-02 19:10:57 +01:00
hKeyDst = NULL;
if (!RegOpenKeyA(HKEY_CURRENT_USER, REG_TEST_KEY "\\CopyDestination", &hKeyDst) && hKeyDst)
{
SHDeleteKeyA(hKeyDst, NULL);
RegCloseKey(hKeyDst);
}
2002-12-02 19:10:57 +01:00
hKeyDst = NULL;
2005-02-03 20:38:58 +01:00
dwRet = RegCreateKeyA(HKEY_CURRENT_USER, REG_TEST_KEY "\\CopyDestination", &hKeyDst);
if (dwRet || !hKeyDst)
{
ok( 0, "Destination couldn't be created, RegCreateKeyA returned (%u)\n", dwRet);
return;
}
2002-12-02 19:10:57 +01:00
hKeySrc = NULL;
2005-02-03 20:38:58 +01:00
dwRet = RegOpenKeyA(HKEY_LOCAL_MACHINE, REG_CURRENT_VERSION, &hKeySrc);
if (dwRet || !hKeySrc)
{
ok( 0, "Source couldn't be opened, RegOpenKeyA returned (%u)\n", dwRet);
RegCloseKey(hKeyDst);
return;
}
dwRet = (*pSHCopyKeyA)(hKeySrc, NULL, hKeyDst, 0);
ok ( ERROR_SUCCESS == dwRet, "Copy failed, ret=(%u)\n", dwRet);
RegCloseKey(hKeySrc);
RegCloseKey(hKeyDst);
/* Check we copied the sub keys, i.e. something that's on every windows system (including Wine) */
2002-12-02 19:10:57 +01:00
hKeyDst = NULL;
dwRet = RegOpenKeyA(HKEY_CURRENT_USER, REG_TEST_KEY "\\CopyDestination\\Shell Folders", &hKeyDst);
2005-02-03 20:38:58 +01:00
if (dwRet || !hKeyDst)
{
ok ( 0, "Copy couldn't be opened, RegOpenKeyA returned (%u)\n", dwRet);
return;
}
/* And the we copied the values too */
ok(!SHQueryValueExA(hKeyDst, "Common AppData", NULL, NULL, NULL, NULL), "SHQueryValueExA failed\n");
RegCloseKey(hKeyDst);
}
2005-06-20 16:18:03 +02:00
static void test_SHDeleteKey(void)
{
2005-02-03 20:38:58 +01:00
HKEY hKeyTest, hKeyS;
DWORD dwRet;
int sysfail = 1;
if (!RegOpenKeyA(HKEY_CURRENT_USER, REG_TEST_KEY, &hKeyTest))
{
if (!RegCreateKey(hKeyTest, "ODBC", &hKeyS))
{
HKEY hKeyO;
2005-02-03 20:38:58 +01:00
if (!RegCreateKey(hKeyS, "ODBC.INI", &hKeyO))
{
RegCloseKey (hKeyO);
2005-02-03 20:38:58 +01:00
if (!RegCreateKey(hKeyS, "ODBCINST.INI", &hKeyO))
{
RegCloseKey (hKeyO);
sysfail = 0;
}
}
RegCloseKey (hKeyS);
}
RegCloseKey (hKeyTest);
}
2005-02-03 20:38:58 +01:00
if (!sysfail)
{
2005-02-03 20:38:58 +01:00
dwRet = SHDeleteKeyA(HKEY_CURRENT_USER, REG_TEST_KEY "\\ODBC");
ok ( ERROR_SUCCESS == dwRet, "SHDeleteKey failed, ret=(%u)\n", dwRet);
2005-02-03 20:38:58 +01:00
dwRet = RegOpenKeyA(HKEY_CURRENT_USER, REG_TEST_KEY "\\ODBC", &hKeyS);
ok ( ERROR_FILE_NOT_FOUND == dwRet, "SHDeleteKey did not delete\n");
if (dwRet == ERROR_SUCCESS)
RegCloseKey (hKeyS);
}
else
2005-02-03 20:38:58 +01:00
ok( 0, "Could not set up SHDeleteKey test\n");
}
2002-05-09 21:48:07 +02:00
START_TEST(shreg)
{
2002-09-13 00:29:58 +02:00
HKEY hkey = create_test_entries();
if (!hkey) return;
hshlwapi = GetModuleHandleA("shlwapi.dll");
pSHCopyKeyA=(SHCopyKeyA_func)GetProcAddress(hshlwapi,"SHCopyKeyA");
pSHRegGetPathA=(SHRegGetPathA_func)GetProcAddress(hshlwapi,"SHRegGetPathA");
2002-05-09 21:48:07 +02:00
test_SHGetValue();
test_SHQUeryValueEx();
test_SHGetRegPath();
test_SHCopyKey();
test_SHDeleteKey();
delete_key( hkey, "Software\\Wine", "Test" );
2002-05-09 21:48:07 +02:00
}