shellpath.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "shlguid.h"
#include "shlobj.h"
#include "shlwapi.h"
#include "knownfolders.h"
#include "shellapi.h"
#include "wine/test.h"
#include "initguid.h"

Include dependency graph for shellpath.c:

Go to the source code of this file.

Classes
struct	shellExpectedValues
struct	knownFolderDef

Macros
#define	COBJMACROS
#define	OLD_CSIDL_MYDOCUMENTS   0x000c
#define	PT_CPL   0x01 /* no path */
#define	PT_GUID   0x1f /* no path */
#define	PT_DRIVE   0x23 /* has path */
#define	PT_DRIVE2   0x25 /* has path */
#define	PT_SHELLEXT   0x2e /* no path */
#define	PT_FOLDER   0x31 /* has path */
#define	PT_FOLDERW   0x35 /* has path */
#define	PT_WORKGRP   0x41 /* no path */
#define	PT_YAGUID   0x70 /* no path */
#define	PT_IESPECIAL2   0xb1 /* has path */
#define	DECLARE_TYPE(x, y)   { x, ARRAY_SIZE(y), y }
#define	GET_PROC(func)
#define	CSIDL_PROFILES   0x003e
#define	CSIDL_TO_STR(x)   case x: return#x;
#define	NO_CSIDL   0x10000
#define	WINE_ATTRIBUTES_OPTIONAL   0x20000
#define	KNOWN_FOLDER(id, csidl, name, category, parent1, parent2, relative_path, parsing_name, attributes, definitionFlags)   { &id, # id, csidl, # csidl, name, category, {&parent1, &parent2}, relative_path, parsing_name, attributes, definitionFlags, __LINE__ }

Functions
	DEFINE_GUID (GUID_NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
static	HRESULT (WINAPI *pDllGetVersion)(DLLVERSIONINFO *)
static LPITEMIDLIST *static	BOOL (WINAPI *pSHGetSpecialFolderPathA)(HWND
static LPITEMIDLIST *static	LPITEMIDLIST (WINAPI *pILFindLastID)(LPCITEMIDLIST)
static	int (WINAPI *pSHFileOperationA)(LPSHFILEOPSTRUCTA)
static	UINT (WINAPI *pGetSystemWow64DirectoryA)(LPSTR
static void	loadShell32 (void)
static const char *	getFolderName (int folder)
static void	test_parameters (void)
static BYTE	testSHGetFolderLocation (int folder)
static BYTE	testSHGetSpecialFolderLocation (int folder)
static void	test_SHGetFolderPath (BOOL optional, int folder)
static void	test_SHGetSpecialFolderPath (BOOL optional, int folder)
static void	test_ShellValues (const struct shellExpectedValues testEntries[], int numEntries, BOOL optional)
static void	matchSpecialFolderPathToEnv (int folder, const char *envVar)
static void	matchGUID (int folder, const GUID *guid, const GUID *guid_alt)
static void	test_PidlTypes (void)
	DEFINE_GUID (CLSID_NetworkExplorerFolder, 0xF02C1A0D, 0xBE21, 0x4350, 0x88, 0xB0, 0x73, 0x67, 0xFC, 0x96, 0xEF, 0x3C)
	DEFINE_GUID (_CLSID_Documents, 0xA8CDFF1C, 0x4878, 0x43be, 0xB5, 0xFD, 0xF8, 0x09, 0x1C, 0x1C, 0x60, 0xD0)
static void	test_GUIDs (void)
static void	test_EnvVars (void)
static BOOL	myPathIsRootA (LPCSTR lpszPath)
static LPSTR	myPathRemoveBackslashA (LPSTR lpszPath)
static void	testWinDir (void)
static void	testSystemDir (void)
static BOOL	init (void)
static void	doChild (const char *arg)
static void	test_NonExistentPath (void)
static void	test_SHGetFolderPathEx (void)
static BOOL	is_in_strarray (const WCHAR *needle, const char *hay)
static void	check_known_folder (IKnownFolderManager *mgr, KNOWNFOLDERID *folderId)
static void	test_knownFolders (void)
static void	test_DoEnvironmentSubst (void)
static void	test_PathYetAnotherMakeUniqueName (void)
static void	test_SHGetKnownFolderIDList (void)
	START_TEST (shellpath)

Variables
static GUID	CLSID_CommonDocuments = { 0x0000000c, 0x0000, 0x0000, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0x1a } }
static	int
static	HANDLE
static	DWORD
static	LPSTR
static LPITEMIDLIST *static	BOOL
static	UINT
static PWSTR *static	PWSTR
static	LPWSTR
static	PCWSTR
static PIDLIST_ABSOLUTE *static DLLVERSIONINFO	shellVersion = { 0 }
static LPMALLOC	pMalloc
static const BYTE	guidType [] = { PT_GUID }
static const BYTE	controlPanelType [] = { PT_SHELLEXT, PT_GUID, PT_CPL }
static const BYTE	folderType [] = { PT_FOLDER, PT_FOLDERW }
static const BYTE	favoritesType [] = { PT_FOLDER, PT_FOLDERW, 0, PT_IESPECIAL2 }
static const BYTE	folderOrSpecialType [] = { PT_FOLDER, PT_IESPECIAL2 }
static const BYTE	personalType []
static const BYTE	printersType [] = { PT_YAGUID, PT_SHELLEXT, 0x71 }
static const BYTE	ieSpecialType [] = { PT_IESPECIAL2 }
static const BYTE	shellExtType [] = { PT_SHELLEXT }
static const BYTE	workgroupType [] = { PT_WORKGRP }
static const struct shellExpectedValues	requiredShellValues []
static const struct shellExpectedValues	optionalShellValues []
static const GUID	_FOLDERID_CryptoKeys = {0xB88F4DAA, 0xE7BD, 0x49A9, {0xB7, 0x4D, 0x02, 0x88, 0x5A, 0x5D, 0xC7, 0x65} }
static const GUID	_FOLDERID_DpapiKeys = {0x10C07CD0, 0xEF91, 0x4567, {0xB8, 0x50, 0x44, 0x8B, 0x77, 0xCB, 0x37, 0xF9} }
static const GUID	_FOLDERID_SystemCertificates = {0x54EED2E0, 0xE7CA, 0x4FDB, {0x91, 0x48, 0x0F, 0x42, 0x47, 0x29, 0x1C, 0xFA} }
static const GUID	_FOLDERID_CredentialManager = {0x915221FB, 0x9EFE, 0x4BDA, {0x8F, 0xD7, 0xF7, 0x8D, 0xCA, 0x77, 0x4F, 0x87} }
static const struct knownFolderDef	known_folders []
BOOL	known_folder_found [ARRAY_SIZE(known_folders)]
static int	myARGC
static char **	myARGV
static char	base [MAX_PATH]
static char	selfname [MAX_PATH]

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 24 of file shellpath.c.

CSIDL_PROFILES

#define CSIDL_PROFILES   0x003e

Definition at line 231 of file shellpath.c.

CSIDL_TO_STR

#define CSIDL_TO_STR

(

x

)

case x: return#x;

DECLARE_TYPE

#define DECLARE_TYPE	(		x,
			y
	)		{ x, ARRAY_SIZE(y), y }

Definition at line 117 of file shellpath.c.

GET_PROC

#define GET_PROC

(

func

)

Value:

p ## func = (void*)GetProcAddress(hShell32, #func); \
    if(!p ## func) \
      trace("GetProcAddress(%s) failed\n", #func);

KNOWN_FOLDER

#define KNOWN_FOLDER	(		id,
			csidl,
			name,
			category,
			parent1,
			parent2,
			relative_path,
			parsing_name,
			attributes,
			definitionFlags
	)		{ &id, # id, csidl, # csidl, name, category, {&parent1, &parent2}, relative_path, parsing_name, attributes, definitionFlags, __LINE__ }

Definition at line 310 of file shellpath.c.

NO_CSIDL

#define NO_CSIDL   0x10000

Definition at line 308 of file shellpath.c.

OLD_CSIDL_MYDOCUMENTS

#define OLD_CSIDL_MYDOCUMENTS   0x000c

Definition at line 42 of file shellpath.c.

PT_CPL

#define PT_CPL   0x01 /* no path */

Definition at line 48 of file shellpath.c.

PT_DRIVE

#define PT_DRIVE   0x23 /* has path */

Definition at line 54 of file shellpath.c.

PT_DRIVE2

#define PT_DRIVE2   0x25 /* has path */

Definition at line 57 of file shellpath.c.

PT_FOLDER

#define PT_FOLDER   0x31 /* has path */

Definition at line 63 of file shellpath.c.

PT_FOLDERW

#define PT_FOLDERW   0x35 /* has path */

Definition at line 66 of file shellpath.c.

PT_GUID

#define PT_GUID   0x1f /* no path */

Definition at line 51 of file shellpath.c.

PT_IESPECIAL2

#define PT_IESPECIAL2   0xb1 /* has path */

Definition at line 76 of file shellpath.c.

PT_SHELLEXT

#define PT_SHELLEXT   0x2e /* no path */

Definition at line 60 of file shellpath.c.

PT_WORKGRP

#define PT_WORKGRP   0x41 /* no path */

Definition at line 69 of file shellpath.c.

PT_YAGUID

#define PT_YAGUID   0x70 /* no path */

Definition at line 72 of file shellpath.c.

WINE_ATTRIBUTES_OPTIONAL

#define WINE_ATTRIBUTES_OPTIONAL   0x20000

Definition at line 309 of file shellpath.c.

Function Documentation

BOOL()

static LPITEMIDLIST* static BOOL ( WINAPI *  pSHGetSpecialFolderPathA )

static

check_known_folder()

static void check_known_folder ( IKnownFolderManager *  mgr, KNOWNFOLDERID *  folderId  )

static

Definition at line 1964 of file shellpath.c.

{
    HRESULT hr;
    int csidl, expectedCsidl, ret;
    KNOWNFOLDER_DEFINITION kfd;
    IKnownFolder *folder;
    WCHAR sName[1024];
    BOOL found = FALSE;
    unsigned int i;

    for (i = 0; i < ARRAY_SIZE(known_folders); ++i)
    {
        const struct knownFolderDef *known_folder = &known_folders[i];

        if(IsEqualGUID(known_folder->folderId, folderId))
        {
            known_folder_found[i] = TRUE;
            found = TRUE;
            /* verify CSIDL */
            if(!(known_folder->csidl & NO_CSIDL))
            {
                /* mask off winetest flags */
                expectedCsidl = known_folder->csidl & 0xFFFF;

                hr = IKnownFolderManager_FolderIdToCsidl(mgr, folderId, &csidl);
                ok_(__FILE__, known_folder->line)(hr == S_OK, "cannot retrieve CSIDL for folder %s\n", known_folder->sFolderId);

                ok_(__FILE__, known_folder->line)(csidl == expectedCsidl, "invalid CSIDL retrieved for folder %s. %d (%s) expected, but %d found\n", known_folder->sFolderId, expectedCsidl, known_folder->sCsidl, csidl);
            }

            hr = IKnownFolderManager_GetFolder(mgr, folderId, &folder);
            ok_(__FILE__, known_folder->line)(hr == S_OK, "cannot get known folder for %s\n", known_folder->sFolderId);
            if(SUCCEEDED(hr))
            {
                hr = IKnownFolder_GetFolderDefinition(folder, &kfd);
                ok_(__FILE__, known_folder->line)(hr == S_OK, "cannot get known folder definition for %s\n", known_folder->sFolderId);
                if(SUCCEEDED(hr))
                {
                    ret = MultiByteToWideChar(CP_ACP, 0, known_folder->sName, -1,  sName, ARRAY_SIZE(sName));
                    ok_(__FILE__, known_folder->line)(ret != 0, "cannot convert known folder name \"%s\" to wide characters\n", known_folder->sName);

                    ok_(__FILE__, known_folder->line)(lstrcmpW(kfd.pszName, sName)==0, "invalid known folder name returned for %s: %s expected, but %s retrieved\n", known_folder->sFolderId, wine_dbgstr_w(sName), wine_dbgstr_w(kfd.pszName));

                    ok_(__FILE__, known_folder->line)(kfd.category == known_folder->category, "invalid known folder category for %s: %d expected, but %d retrieved\n", known_folder->sFolderId, known_folder->category, kfd.category);

                    ok_(__FILE__, known_folder->line)(IsEqualGUID(known_folder->fidParents[0], &kfd.fidParent) ||
                                                              IsEqualGUID(known_folder->fidParents[1], &kfd.fidParent),
                                                      "invalid known folder parent for %s: %s retrieved\n",
                                                      known_folder->sFolderId, wine_dbgstr_guid(&kfd.fidParent));

                    ok_(__FILE__, known_folder->line)(is_in_strarray(kfd.pszRelativePath, known_folder->sRelativePath), "invalid known folder relative path returned for %s: %s expected, but %s retrieved\n", known_folder->sFolderId, known_folder->sRelativePath, wine_dbgstr_w(kfd.pszRelativePath));

                    ok_(__FILE__, known_folder->line)(is_in_strarray(kfd.pszParsingName, known_folder->sParsingName), "invalid known folder parsing name returned for %s: %s retrieved\n", known_folder->sFolderId, wine_dbgstr_w(kfd.pszParsingName));

                    ok_(__FILE__, known_folder->line)(known_folder->attributes == kfd.dwAttributes ||
                            (known_folder->csidl & WINE_ATTRIBUTES_OPTIONAL && kfd.dwAttributes == 0),
                            "invalid known folder attributes for %s: 0x%08x expected, but 0x%08x retrieved\n", known_folder->sFolderId, known_folder->attributes, kfd.dwAttributes);

                    ok_(__FILE__, known_folder->line)(!(kfd.kfdFlags & (~known_folder->definitionFlags)), "invalid known folder flags for %s: 0x%08x expected, but 0x%08x retrieved\n", known_folder->sFolderId, known_folder->definitionFlags, kfd.kfdFlags);

                    FreeKnownFolderDefinitionFields(&kfd);
                }

            IKnownFolder_Release(folder);
            }

            break;
        }
    }

    if(!found)
    {
        trace("unknown known folder found: %s\n", wine_dbgstr_guid(folderId));

        hr = IKnownFolderManager_GetFolder(mgr, folderId, &folder);
        ok(hr == S_OK, "cannot get known folder for %s\n", wine_dbgstr_guid(folderId));
        if(SUCCEEDED(hr))
        {
            hr = IKnownFolder_GetFolderDefinition(folder, &kfd);
            todo_wine
            ok(hr == S_OK, "cannot get known folder definition for %s\n", wine_dbgstr_guid(folderId));
            if(SUCCEEDED(hr))
            {
                trace("  category: %d\n", kfd.category);
                trace("  name: %s\n", wine_dbgstr_w(kfd.pszName));
                trace("  description: %s\n", wine_dbgstr_w(kfd.pszDescription));
                trace("  parent: %s\n", wine_dbgstr_guid(&kfd.fidParent));
                trace("  relative path: %s\n", wine_dbgstr_w(kfd.pszRelativePath));
                trace("  parsing name: %s\n", wine_dbgstr_w(kfd.pszParsingName));
                trace("  tooltip: %s\n", wine_dbgstr_w(kfd.pszTooltip));
                trace("  localized name: %s\n", wine_dbgstr_w(kfd.pszLocalizedName));
                trace("  icon: %s\n", wine_dbgstr_w(kfd.pszIcon));
                trace("  security: %s\n", wine_dbgstr_w(kfd.pszSecurity));
                trace("  attributes: 0x%08x\n", kfd.dwAttributes);
                trace("  flags: 0x%08x\n", kfd.kfdFlags);
                trace("  type: %s\n", wine_dbgstr_guid(&kfd.ftidType));
                FreeKnownFolderDefinitionFields(&kfd);
            }

            IKnownFolder_Release(folder);
        }
    }
}

Referenced by test_knownFolders().

DEFINE_GUID() [1/3]

DEFINE_GUID	(	GUID_NULL	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0
	)

DEFINE_GUID() [2/3]

DEFINE_GUID	(	CLSID_NetworkExplorerFolder	,
		0xF02C1A0D	,
		0xBE21	,
		0x4350	,
		0x88	,
		0xB0	,
		0x73	,
		0x67	,
		0xFC	,
		0x96	,
		0xEF	,
		0x3C
	)

DEFINE_GUID() [3/3]

DEFINE_GUID	(	_CLSID_Documents	,
		0xA8CDFF1C	,
		0x4878	,
		0x43be	,
		0xB5	,
		0xFD	,
		0xF8	,
		0x09	,
		0x1C	,
		0x1C	,
		0x60	,
		0xD0
	)

doChild()

static void doChild ( const char *  arg )

static

Definition at line 1693 of file shellpath.c.

{
    char path[MAX_PATH];
    HRESULT hr;

    if (arg[0] == '1')
    {
        LPITEMIDLIST pidl;
        char *p;

        /* test what happens when CSIDL_FAVORITES is set to a nonexistent directory */

        /* test some failure cases first: */
        hr = pSHGetFolderPathA(NULL, CSIDL_FAVORITES, NULL, SHGFP_TYPE_CURRENT, path);
        ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
            "SHGetFolderPath returned 0x%08x, expected 0x80070002\n", hr);

        pidl = NULL;
        hr = pSHGetFolderLocation(NULL, CSIDL_FAVORITES, NULL, 0, &pidl);
        ok(hr == E_FAIL || hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
            "SHGetFolderLocation returned 0x%08x\n", hr);
        if (hr == S_OK && pidl) IMalloc_Free(pMalloc, pidl);

        ok(!pSHGetSpecialFolderPathA(NULL, path, CSIDL_FAVORITES, FALSE),
            "SHGetSpecialFolderPath succeeded, expected failure\n");

        pidl = NULL;
        hr = pSHGetSpecialFolderLocation(NULL, CSIDL_FAVORITES, &pidl);
        ok(hr == E_FAIL || hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
            "SHGetFolderLocation returned 0x%08x\n", hr);

        if (hr == S_OK && pidl) IMalloc_Free(pMalloc, pidl);

        /* now test success: */
        hr = pSHGetFolderPathA(NULL, CSIDL_FAVORITES | CSIDL_FLAG_CREATE, NULL,
                               SHGFP_TYPE_CURRENT, path);
        ok (hr == S_OK, "got 0x%08x\n", hr);
        if (hr == S_OK)
        {
            BOOL ret;

            trace("CSIDL_FAVORITES was changed to %s\n", path);
            ret = CreateDirectoryA(path, NULL);
            ok(!ret, "expected failure with ERROR_ALREADY_EXISTS\n");
            if (!ret)
                ok(GetLastError() == ERROR_ALREADY_EXISTS,
                  "got %d, expected ERROR_ALREADY_EXISTS\n", GetLastError());

            p = path + strlen(path);
            strcpy(p, "\\desktop.ini");
            DeleteFileA(path);
            *p = 0;
            SetFileAttributesA( path, FILE_ATTRIBUTE_NORMAL );
            ret = RemoveDirectoryA(path);
            ok( ret, "failed to remove %s error %u\n", path, GetLastError() );
        }
    }
    else if (arg[0] == '2')
    {
        /* make sure SHGetFolderPath still succeeds when the
           original value of CSIDL_FAVORITES is restored. */
        hr = pSHGetFolderPathA(NULL, CSIDL_FAVORITES | CSIDL_FLAG_CREATE, NULL,
            SHGFP_TYPE_CURRENT, path);
        ok(hr == S_OK, "SHGetFolderPath failed: 0x%08x\n", hr);
    }
}

Referenced by START_TEST().

getFolderName()

static const char* getFolderName ( int  folder )

static

Definition at line 235 of file shellpath.c.

{
    static char unknown[32];

#define CSIDL_TO_STR(x) case x: return#x;
    switch (folder)
    {
    CSIDL_TO_STR(CSIDL_DESKTOP);
    CSIDL_TO_STR(CSIDL_INTERNET);
    CSIDL_TO_STR(CSIDL_PROGRAMS);
    CSIDL_TO_STR(CSIDL_CONTROLS);
    CSIDL_TO_STR(CSIDL_PRINTERS);
    CSIDL_TO_STR(CSIDL_PERSONAL);
    CSIDL_TO_STR(CSIDL_FAVORITES);
    CSIDL_TO_STR(CSIDL_STARTUP);
    CSIDL_TO_STR(CSIDL_RECENT);
    CSIDL_TO_STR(CSIDL_SENDTO);
    CSIDL_TO_STR(CSIDL_BITBUCKET);
    CSIDL_TO_STR(CSIDL_STARTMENU);
    CSIDL_TO_STR(OLD_CSIDL_MYDOCUMENTS);
    CSIDL_TO_STR(CSIDL_MYMUSIC);
    CSIDL_TO_STR(CSIDL_MYVIDEO);
    CSIDL_TO_STR(CSIDL_DESKTOPDIRECTORY);
    CSIDL_TO_STR(CSIDL_DRIVES);
    CSIDL_TO_STR(CSIDL_NETWORK);
    CSIDL_TO_STR(CSIDL_NETHOOD);
    CSIDL_TO_STR(CSIDL_FONTS);
    CSIDL_TO_STR(CSIDL_TEMPLATES);
    CSIDL_TO_STR(CSIDL_COMMON_STARTMENU);
    CSIDL_TO_STR(CSIDL_COMMON_PROGRAMS);
    CSIDL_TO_STR(CSIDL_COMMON_STARTUP);
    CSIDL_TO_STR(CSIDL_COMMON_DESKTOPDIRECTORY);
    CSIDL_TO_STR(CSIDL_APPDATA);
    CSIDL_TO_STR(CSIDL_PRINTHOOD);
    CSIDL_TO_STR(CSIDL_LOCAL_APPDATA);
    CSIDL_TO_STR(CSIDL_ALTSTARTUP);
    CSIDL_TO_STR(CSIDL_COMMON_ALTSTARTUP);
    CSIDL_TO_STR(CSIDL_COMMON_FAVORITES);
    CSIDL_TO_STR(CSIDL_INTERNET_CACHE);
    CSIDL_TO_STR(CSIDL_COOKIES);
    CSIDL_TO_STR(CSIDL_HISTORY);
    CSIDL_TO_STR(CSIDL_COMMON_APPDATA);
    CSIDL_TO_STR(CSIDL_WINDOWS);
    CSIDL_TO_STR(CSIDL_SYSTEM);
    CSIDL_TO_STR(CSIDL_PROGRAM_FILES);
    CSIDL_TO_STR(CSIDL_MYPICTURES);
    CSIDL_TO_STR(CSIDL_PROFILE);
    CSIDL_TO_STR(CSIDL_SYSTEMX86);
    CSIDL_TO_STR(CSIDL_PROGRAM_FILESX86);
    CSIDL_TO_STR(CSIDL_PROGRAM_FILES_COMMON);
    CSIDL_TO_STR(CSIDL_PROGRAM_FILES_COMMONX86);
    CSIDL_TO_STR(CSIDL_COMMON_TEMPLATES);
    CSIDL_TO_STR(CSIDL_COMMON_DOCUMENTS);
    CSIDL_TO_STR(CSIDL_COMMON_ADMINTOOLS);
    CSIDL_TO_STR(CSIDL_ADMINTOOLS);
    CSIDL_TO_STR(CSIDL_CONNECTIONS);
    CSIDL_TO_STR(CSIDL_PROFILES);
    CSIDL_TO_STR(CSIDL_COMMON_MUSIC);
    CSIDL_TO_STR(CSIDL_COMMON_PICTURES);
    CSIDL_TO_STR(CSIDL_COMMON_VIDEO);
    CSIDL_TO_STR(CSIDL_RESOURCES);
    CSIDL_TO_STR(CSIDL_RESOURCES_LOCALIZED);
    CSIDL_TO_STR(CSIDL_COMMON_OEM_LINKS);
    CSIDL_TO_STR(CSIDL_CDBURN_AREA);
    CSIDL_TO_STR(CSIDL_COMPUTERSNEARME);
#undef CSIDL_TO_STR
    default:
        sprintf(unknown, "unknown (0x%04x)", folder);
        return unknown;
    }
}

Referenced by matchGUID(), test_ShellValues(), test_SHGetFolderPath(), test_SHGetSpecialFolderPath(), testSHGetFolderLocation(), and testSHGetSpecialFolderLocation().

HRESULT()

static HRESULT ( WINAPI *  pDllGetVersion )

static

init()

static BOOL init ( void  )

static

Definition at line 1685 of file shellpath.c.

{
    myARGC = winetest_get_mainargs(&myARGV);
    if (!GetCurrentDirectoryA(sizeof(base), base)) return FALSE;
    strcpy(selfname, myARGV[0]);
    return TRUE;
}

Referenced by START_TEST().

int()

static int ( WINAPI *  pSHFileOperationA )

static

is_in_strarray()

static BOOL is_in_strarray ( const WCHAR *  needle, const char *  hay  )

static

Definition at line 1934 of file shellpath.c.

{
    WCHAR wstr[MAX_PATH];

    if(!needle && !hay)
        return TRUE;

    while(hay && *hay)
    {
        DWORD ret;

        if(strcmp(hay, "(null)") == 0 && !needle)
            return TRUE;

        ret = MultiByteToWideChar(CP_ACP, 0, hay, -1, wstr, ARRAY_SIZE(wstr));
        if(ret == 0)
        {
            ok(0, "Failed to convert string\n");
            return FALSE;
        }

        if(lstrcmpW(wstr, needle) == 0)
            return TRUE;

        hay += strlen(hay) + 1;
    }

    return FALSE;
}

Referenced by check_known_folder().

loadShell32()

static void loadShell32 ( void  )

static

Definition at line 186 of file shellpath.c.

{
    HMODULE hShell32 = GetModuleHandleA("shell32");

#define GET_PROC(func) \
    p ## func = (void*)GetProcAddress(hShell32, #func); \
    if(!p ## func) \
      trace("GetProcAddress(%s) failed\n", #func);

    GET_PROC(DllGetVersion)
    GET_PROC(SHGetFolderPathA)
    GET_PROC(SHGetFolderPathEx)
    GET_PROC(SHGetFolderLocation)
    GET_PROC(SHGetKnownFolderPath)
    GET_PROC(SHSetKnownFolderPath)
    GET_PROC(SHGetSpecialFolderPathA)
    GET_PROC(SHGetSpecialFolderLocation)
    GET_PROC(ILFindLastID)
    if (!pILFindLastID)
        pILFindLastID = (void *)GetProcAddress(hShell32, (LPCSTR)16);
    GET_PROC(SHFileOperationA)
    GET_PROC(SHGetMalloc)
    GET_PROC(PathYetAnotherMakeUniqueName)
    GET_PROC(SHGetKnownFolderIDList)

    ok(pSHGetMalloc != NULL, "shell32 is missing SHGetMalloc\n");
    if (pSHGetMalloc)
    {
        HRESULT hr = pSHGetMalloc(&pMalloc);

        ok(hr == S_OK, "SHGetMalloc failed: 0x%08x\n", hr);
        ok(pMalloc != NULL, "SHGetMalloc returned a NULL IMalloc\n");
    }

    if (pDllGetVersion)
    {
        shellVersion.cbSize = sizeof(shellVersion);
        pDllGetVersion(&shellVersion);
        trace("shell32 version is %d.%d\n",
              shellVersion.dwMajorVersion, shellVersion.dwMinorVersion);
    }
#undef GET_PROC
}

Referenced by START_TEST().

LPITEMIDLIST()

static LPITEMIDLIST* static LPITEMIDLIST ( WINAPI *  pILFindLastID )

static

matchGUID()

static void matchGUID ( int  folder, const GUID *  guid, const GUID *  guid_alt  )

static

Definition at line 1529 of file shellpath.c.

{
    LPITEMIDLIST pidl;
    HRESULT hr;

    if (!pSHGetFolderLocation) return;
    if (!guid) return;

    pidl = NULL;
    hr = pSHGetFolderLocation(NULL, folder, NULL, 0, &pidl);
    if (hr == S_OK)
    {
        LPITEMIDLIST pidlLast = pILFindLastID(pidl);

        if (pidlLast && (pidlLast->mkid.abID[0] == PT_SHELLEXT ||
         pidlLast->mkid.abID[0] == PT_GUID))
        {
            GUID *shellGuid = (GUID *)(pidlLast->mkid.abID + 2);

            if (!guid_alt)
             ok(IsEqualIID(shellGuid, guid),
              "%s: got GUID %s, expected %s\n", getFolderName(folder),
              wine_dbgstr_guid(shellGuid), wine_dbgstr_guid(guid));
            else
             ok(IsEqualIID(shellGuid, guid) ||
              IsEqualIID(shellGuid, guid_alt),
              "%s: got GUID %s, expected %s or %s\n", getFolderName(folder),
              wine_dbgstr_guid(shellGuid), wine_dbgstr_guid(guid), wine_dbgstr_guid(guid_alt));
        }
        IMalloc_Free(pMalloc, pidl);
    }
}

Referenced by test_GUIDs().

matchSpecialFolderPathToEnv()

static void matchSpecialFolderPathToEnv ( int  folder, const char *  envVar  )

static

Definition at line 1507 of file shellpath.c.

{
    char path[MAX_PATH];

    if (!pSHGetSpecialFolderPathA) return;

    if (pSHGetSpecialFolderPathA(NULL, path, folder, FALSE))
    {
        char *envVal = getenv(envVar);

        ok(!envVal || !lstrcmpiA(envVal, path),
         "%%%s%% does not match SHGetSpecialFolderPath:\n"
         "%%%s%% is %s\nSHGetSpecialFolderPath returns %s\n",
         envVar, envVar, envVal, path);
    }
}

Referenced by test_EnvVars().

myPathIsRootA()

static BOOL myPathIsRootA ( LPCSTR  lpszPath )

static

Definition at line 1606 of file shellpath.c.

{
  if (lpszPath && *lpszPath &&
      lpszPath[1] == ':' && lpszPath[2] == '\\' && lpszPath[3] == '\0')
      return TRUE; /* X:\ */
  return FALSE;
}

Referenced by myPathRemoveBackslashA().

myPathRemoveBackslashA()

static LPSTR myPathRemoveBackslashA ( LPSTR  lpszPath )

static

Definition at line 1613 of file shellpath.c.

{
  LPSTR szTemp = NULL;

  if(lpszPath)
  {
    szTemp = CharPrevA(lpszPath, lpszPath + strlen(lpszPath));
    if (!myPathIsRootA(lpszPath) && *szTemp == '\\')
      *szTemp = '\0';
  }
  return szTemp;
}

Referenced by testSystemDir(), and testWinDir().

START_TEST()

START_TEST

(

shellpath

)

Definition at line 2842 of file shellpath.c.

{
    if (!init()) return;

    loadShell32();
    pGetSystemWow64DirectoryA = (void *)GetProcAddress( GetModuleHandleA("kernel32.dll"),
                                                        "GetSystemWow64DirectoryA" );
    if (myARGC >= 3)
        doChild(myARGV[2]);
    else
    {
        /* Report missing functions once */
        if (!pSHGetFolderLocation)
            win_skip("SHGetFolderLocation is not available\n");

        /* first test various combinations of parameters: */
        test_parameters();

        /* check known values: */
        test_PidlTypes();
        test_GUIDs();
        test_EnvVars();
        testWinDir();
        testSystemDir();
        test_NonExistentPath();
        test_SHGetFolderPathEx();
        test_knownFolders();
        test_DoEnvironmentSubst();
        test_PathYetAnotherMakeUniqueName();
        test_SHGetKnownFolderIDList();
    }
}

test_DoEnvironmentSubst()

static void test_DoEnvironmentSubst ( void  )

static

Definition at line 2557 of file shellpath.c.

{
    WCHAR expectedW[MAX_PATH];
    WCHAR bufferW[MAX_PATH];
    CHAR  expectedA[MAX_PATH];
    CHAR  bufferA[MAX_PATH];
    DWORD res;
    DWORD res2;
    DWORD len;
    INT   i;
    static const WCHAR does_not_existW[] = {'%','D','O','E','S','_','N','O','T','_','E','X','I','S','T','%',0};
    static const CHAR  does_not_existA[] = "%DOES_NOT_EXIST%";
    static const CHAR  *names[] = {
                            /* interactive apps and services (works on all windows versions) */
                            "%ALLUSERSPROFILE%", "%APPDATA%", "%LOCALAPPDATA%",
                            "%NUMBER_OF_PROCESSORS%", "%OS%", "%PROCESSOR_ARCHITECTURE%",
                            "%PROCESSOR_IDENTIFIER%", "%PROCESSOR_LEVEL%", "%PROCESSOR_REVISION%",
                            "%ProgramFiles%", "%SystemDrive%",
                            "%SystemRoot%", "%USERPROFILE%", "%windir%",
                            /* todo_wine: "%COMPUTERNAME%", "%ProgramData%", "%PUBLIC%", */

                            /* replace more than one var is allowed */
                            "%HOMEDRIVE%%HOMEPATH%",
                            "%OS% %windir%"}; /* always the last entry in the table */

    for (i = 0; i < (ARRAY_SIZE(names)); i++)
    {
        memset(bufferA, '#', MAX_PATH - 1);
        bufferA[MAX_PATH - 1] = 0;
        lstrcpyA(bufferA, names[i]);
        MultiByteToWideChar(CP_ACP, 0, bufferA, MAX_PATH, bufferW, ARRAY_SIZE(bufferW));

        res2 = ExpandEnvironmentStringsA(names[i], expectedA, MAX_PATH);
        res = DoEnvironmentSubstA(bufferA, MAX_PATH);

        /* is the space for the terminating 0 included? */
        if (!i && HIWORD(res) && (LOWORD(res) == (lstrlenA(bufferA))))
        {
            win_skip("DoEnvironmentSubstA/W are broken on NT 4\n");
            return;
        }
        ok(HIWORD(res) && (LOWORD(res) == res2),
            "%d: got %d/%d (expected TRUE/%d)\n", i, HIWORD(res), LOWORD(res), res2);
        ok(!lstrcmpA(bufferA, expectedA),
            "%d: got %s (expected %s)\n", i, bufferA, expectedA);

        res2 = ExpandEnvironmentStringsW(bufferW, expectedW, MAX_PATH);
        res = DoEnvironmentSubstW(bufferW, MAX_PATH);
        ok(HIWORD(res) && (LOWORD(res) == res2),
            "%d: got %d/%d (expected TRUE/%d)\n", i, HIWORD(res), LOWORD(res), res2);
        ok(!lstrcmpW(bufferW, expectedW),
            "%d: got %s (expected %s)\n", i, wine_dbgstr_w(bufferW), wine_dbgstr_w(expectedW));
    }

    i--; /* reuse data in the last table entry */
    len = LOWORD(res); /* needed length */

    /* one character extra is fine */
    memset(bufferA, '#', MAX_PATH - 1);
    bufferA[len + 2] = 0;
    lstrcpyA(bufferA, names[i]);
    MultiByteToWideChar(CP_ACP, 0, bufferA, MAX_PATH, bufferW, ARRAY_SIZE(bufferW));

    res2 = ExpandEnvironmentStringsA(bufferA, expectedA, MAX_PATH);
    res = DoEnvironmentSubstA(bufferA, len + 1);
    ok(HIWORD(res) && (LOWORD(res) == res2),
        "+1: got %d/%d (expected TRUE/%d)\n", HIWORD(res), LOWORD(res), res2);
    ok(!lstrcmpA(bufferA, expectedA),
        "+1: got %s (expected %s)\n", bufferA, expectedA);

    res2 = ExpandEnvironmentStringsW(bufferW, expectedW, MAX_PATH);
    res = DoEnvironmentSubstW(bufferW, len + 1);
    ok(HIWORD(res) && (LOWORD(res) == res2),
        "+1: got %d/%d (expected TRUE/%d)\n", HIWORD(res), LOWORD(res), res2);
    ok(!lstrcmpW(bufferW, expectedW),
        "+1: got %s (expected %s)\n", wine_dbgstr_w(bufferW), wine_dbgstr_w(expectedW));


    /* minimal buffer length (result string and terminating 0) */
    memset(bufferA, '#', MAX_PATH - 1);
    bufferA[len + 2] = 0;
    lstrcpyA(bufferA, names[i]);
    MultiByteToWideChar(CP_ACP, 0, bufferA, MAX_PATH, bufferW, ARRAY_SIZE(bufferW));

    /* ANSI version failed without an extra byte, as documented on msdn */
    res = DoEnvironmentSubstA(bufferA, len);
    ok(!HIWORD(res) && (LOWORD(res) == len),
        " 0: got %d/%d  (expected FALSE/%d)\n", HIWORD(res), LOWORD(res), len);
    ok(!lstrcmpA(bufferA, names[i]),
        " 0: got %s (expected %s)\n", bufferA, names[i]);

    /* DoEnvironmentSubstW works as expected */
    res2 = ExpandEnvironmentStringsW(bufferW, expectedW, MAX_PATH);
    res = DoEnvironmentSubstW(bufferW, len);
    ok(HIWORD(res) && (LOWORD(res) == res2),
        " 0: got %d/%d (expected TRUE/%d)\n", HIWORD(res), LOWORD(res), res2);
    ok(!lstrcmpW(bufferW, expectedW),
        " 0: got %s (expected %s)\n", wine_dbgstr_w(bufferW), wine_dbgstr_w(expectedW));


    /* Buffer too small */
    /* result: FALSE / provided buffer length / the buffer is untouched */
    memset(bufferA, '#', MAX_PATH - 1);
    bufferA[len + 2] = 0;
    lstrcpyA(bufferA, names[i]);
    MultiByteToWideChar(CP_ACP, 0, bufferA, MAX_PATH, bufferW, ARRAY_SIZE(bufferW));

    res = DoEnvironmentSubstA(bufferA, len - 1);
    ok(!HIWORD(res) && (LOWORD(res) == (len - 1)),
        "-1: got %d/%d  (expected FALSE/%d)\n", HIWORD(res), LOWORD(res), len - 1);
    ok(!lstrcmpA(bufferA, names[i]),
        "-1: got %s (expected %s)\n", bufferA, names[i]);

    lstrcpyW(expectedW, bufferW);
    res = DoEnvironmentSubstW(bufferW, len - 1);
    ok(!HIWORD(res) && (LOWORD(res) == (len - 1)),
        "-1: got %d/%d  (expected FALSE/%d)\n", HIWORD(res), LOWORD(res), len - 1);
    ok(!lstrcmpW(bufferW, expectedW),
        "-1: got %s (expected %s)\n", wine_dbgstr_w(bufferW), wine_dbgstr_w(expectedW));


    /* unknown variable */
    /* result: TRUE / string length including terminating 0 / the buffer is untouched */
    memset(bufferA, '#', MAX_PATH - 1);
    bufferA[MAX_PATH - 1] = 0;
    lstrcpyA(bufferA, does_not_existA);
    MultiByteToWideChar(CP_ACP, 0, bufferA, MAX_PATH, bufferW, ARRAY_SIZE(bufferW));

    res2 = lstrlenA(does_not_existA) + 1;
    res = DoEnvironmentSubstA(bufferA, MAX_PATH);
    ok(HIWORD(res) && (LOWORD(res) == res2),
            "%d: got %d/%d (expected TRUE/%d)\n", i, HIWORD(res), LOWORD(res), res2);
    ok(!lstrcmpA(bufferA, does_not_existA),
        "%d: got %s (expected %s)\n", i, bufferA, does_not_existA);

    res = DoEnvironmentSubstW(bufferW, MAX_PATH);
    ok(HIWORD(res) && (LOWORD(res) == res2),
        "%d: got %d/%d (expected TRUE/%d)\n", i, HIWORD(res), LOWORD(res), res2);
    ok(!lstrcmpW(bufferW, does_not_existW),
        "%d: got %s (expected %s)\n", i, wine_dbgstr_w(bufferW), wine_dbgstr_w(does_not_existW));


    if (0)
    {
        /* NULL crashes on windows */
        res = DoEnvironmentSubstA(NULL, MAX_PATH);
        res = DoEnvironmentSubstW(NULL, MAX_PATH);
    }
}

Referenced by START_TEST().

test_EnvVars()

static void test_EnvVars ( void  )

static

Definition at line 1593 of file shellpath.c.

{
    matchSpecialFolderPathToEnv(CSIDL_PROGRAM_FILES, "ProgramFiles");
    matchSpecialFolderPathToEnv(CSIDL_APPDATA, "APPDATA");
    matchSpecialFolderPathToEnv(CSIDL_PROFILE, "USERPROFILE");
    matchSpecialFolderPathToEnv(CSIDL_WINDOWS, "SystemRoot");
    matchSpecialFolderPathToEnv(CSIDL_WINDOWS, "windir");
    matchSpecialFolderPathToEnv(CSIDL_PROGRAM_FILES_COMMON, "CommonProgramFiles");
    /* this is only set on Wine, but can't hurt to verify it: */
    matchSpecialFolderPathToEnv(CSIDL_SYSTEM, "winsysdir");
}

Referenced by START_TEST().

test_GUIDs()

static void test_GUIDs ( void  )

static

Definition at line 1578 of file shellpath.c.

{
    matchGUID(CSIDL_BITBUCKET, &CLSID_RecycleBin, NULL);
    matchGUID(CSIDL_CONTROLS, &CLSID_ControlPanel, NULL);
    matchGUID(CSIDL_DRIVES, &CLSID_MyComputer, NULL);
    matchGUID(CSIDL_INTERNET, &CLSID_Internet, NULL);
    matchGUID(CSIDL_NETWORK, &CLSID_NetworkPlaces, &CLSID_NetworkExplorerFolder); /* Vista and higher */
    matchGUID(CSIDL_PERSONAL, &CLSID_MyDocuments, &_CLSID_Documents /* win8 */);
    matchGUID(CSIDL_COMMON_DOCUMENTS, &CLSID_CommonDocuments, NULL);
    matchGUID(CSIDL_PRINTERS, &CLSID_Printers, NULL);
}

Referenced by START_TEST().

test_knownFolders()

static void test_knownFolders ( void  )

static

Definition at line 2069 of file shellpath.c.

{
    static const WCHAR sWindows[] = {'W','i','n','d','o','w','s',0};
    static const WCHAR sWindows2[] = {'w','i','n','d','o','w','s',0};
    static const WCHAR sExample[] = {'E','x','a','m','p','l','e',0};
    static const WCHAR sExample2[] = {'E','x','a','m','p','l','e','2',0};
    static const WCHAR sSubFolder[] = {'S','u','b','F','o','l','d','e','r',0};
    static const WCHAR sNoSuch[] = {'N','o','S','u','c','h',0};
    static const WCHAR sBackslash[] = {'\\',0};
    static const KNOWNFOLDERID newFolderId = {0x01234567, 0x89AB, 0xCDEF, {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x01} };
    static const KNOWNFOLDERID subFolderId = {0xFEDCBA98, 0x7654, 0x3210, {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF} };
    HRESULT hr;
    IKnownFolderManager *mgr = NULL;
    IKnownFolder *folder = NULL, *subFolder = NULL;
    KNOWNFOLDERID folderId, *folders;
    KF_CATEGORY cat = 0;
    KNOWNFOLDER_DEFINITION kfDefinition, kfSubDefinition;
    int csidl, i;
    UINT nCount = 0;
    LPWSTR folderPath, errorMsg;
    KF_REDIRECTION_CAPABILITIES redirectionCapabilities = 1;
    WCHAR sWinDir[MAX_PATH], sExamplePath[MAX_PATH], sExample2Path[MAX_PATH], sSubFolderPath[MAX_PATH], sSubFolder2Path[MAX_PATH];
    BOOL bRes;
    DWORD dwAttributes;

    GetWindowsDirectoryW( sWinDir, MAX_PATH );

    GetTempPathW(ARRAY_SIZE(sExamplePath), sExamplePath);
    lstrcatW(sExamplePath, sExample);

    GetTempPathW(ARRAY_SIZE(sExample2Path), sExample2Path);
    lstrcatW(sExample2Path, sExample2);

    lstrcpyW(sSubFolderPath, sExamplePath);
    lstrcatW(sSubFolderPath, sBackslash);
    lstrcatW(sSubFolderPath, sSubFolder);

    lstrcpyW(sSubFolder2Path, sExample2Path);
    lstrcatW(sSubFolder2Path, sBackslash);
    lstrcatW(sSubFolder2Path, sSubFolder);

    CoInitialize(NULL);

    hr = CoCreateInstance(&CLSID_KnownFolderManager, NULL, CLSCTX_INPROC_SERVER,
                          &IID_IKnownFolderManager, (LPVOID*)&mgr);
    if(hr == REGDB_E_CLASSNOTREG)
        win_skip("IKnownFolderManager unavailable\n");
    else
    {
        IUnknown *unk;

        ok(hr == S_OK, "failed to create KnownFolderManager instance: 0x%08x\n", hr);

        hr = IKnownFolderManager_QueryInterface(mgr, &IID_IMarshal, (void**)&unk);
        ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);

        hr = IKnownFolderManager_FolderIdFromCsidl(mgr, CSIDL_WINDOWS, &folderId);
        ok(hr == S_OK, "failed to convert CSIDL to KNOWNFOLDERID: 0x%08x\n", hr);
        ok(IsEqualGUID(&folderId, &FOLDERID_Windows)==TRUE, "invalid KNOWNFOLDERID returned\n");

        hr = IKnownFolderManager_FolderIdToCsidl(mgr, &FOLDERID_Windows, &csidl);
        ok(hr == S_OK, "failed to convert CSIDL to KNOWNFOLDERID: 0x%08x\n", hr);
        ok(csidl == CSIDL_WINDOWS, "invalid CSIDL returned\n");

        hr = IKnownFolderManager_GetFolder(mgr, &FOLDERID_Windows, &folder);
        ok(hr == S_OK, "failed to get known folder: 0x%08x\n", hr);
        if(SUCCEEDED(hr))
        {
            hr = IKnownFolder_QueryInterface(folder, &IID_IMarshal, (void**)&unk);
            ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);

            hr = IKnownFolder_GetCategory(folder, &cat);
            ok(hr == S_OK, "failed to get folder category: 0x%08x\n", hr);
            ok(cat==KF_CATEGORY_FIXED, "invalid folder category: %d\n", cat);

            hr = IKnownFolder_GetId(folder, &folderId);
            ok(hr == S_OK, "failed to get folder id: 0x%08x\n", hr);
            ok(IsEqualGUID(&folderId, &FOLDERID_Windows)==TRUE, "invalid KNOWNFOLDERID returned\n");

            hr = IKnownFolder_GetPath(folder, 0, &folderPath);
            ok(hr == S_OK, "failed to get path from known folder: 0x%08x\n", hr);
            ok(lstrcmpiW(sWinDir, folderPath)==0, "invalid path returned: \"%s\", expected: \"%s\"\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sWinDir));
            CoTaskMemFree(folderPath);

            hr = IKnownFolder_GetRedirectionCapabilities(folder, &redirectionCapabilities);
            ok(hr == S_OK, "failed to get redirection capabilities: 0x%08x\n", hr);
            todo_wine
            ok(redirectionCapabilities==0, "invalid redirection capabilities returned: %d\n", redirectionCapabilities);

            hr = IKnownFolder_SetPath(folder, 0, sWinDir);
            todo_wine
            ok(hr == E_INVALIDARG, "unexpected value from SetPath: 0x%08x\n", hr);

            hr = IKnownFolder_GetFolderDefinition(folder, &kfDefinition);
            ok(hr == S_OK, "failed to get folder definition: 0x%08x\n", hr);
            if(SUCCEEDED(hr))
            {
                ok(kfDefinition.category==KF_CATEGORY_FIXED, "invalid folder category: 0x%08x\n", kfDefinition.category);
                ok(lstrcmpW(kfDefinition.pszName, sWindows)==0, "invalid folder name: %s\n", wine_dbgstr_w(kfDefinition.pszName));
                ok(kfDefinition.dwAttributes==0, "invalid folder attributes: %d\n", kfDefinition.dwAttributes);
                FreeKnownFolderDefinitionFields(&kfDefinition);
            }

            hr = IKnownFolder_Release(folder);
            ok(hr == S_OK, "failed to release KnownFolder instance: 0x%08x\n", hr);
        }

        hr = IKnownFolderManager_GetFolderByName(mgr, sWindows, &folder);
        ok(hr == S_OK, "failed to get known folder: 0x%08x\n", hr);
        if(SUCCEEDED(hr))
        {
            hr = IKnownFolder_GetId(folder, &folderId);
            ok(hr == S_OK, "failed to get folder id: 0x%08x\n", hr);
            ok(IsEqualGUID(&folderId, &FOLDERID_Windows)==TRUE, "invalid KNOWNFOLDERID returned\n");

            hr = IKnownFolder_Release(folder);
            ok(hr == S_OK, "failed to release KnownFolder instance: 0x%08x\n", hr);
        }

        hr = IKnownFolderManager_GetFolderByName(mgr, sWindows2, &folder);
        ok(hr == S_OK, "failed to get known folder: 0x%08x\n", hr);
        if(SUCCEEDED(hr))
        {
            hr = IKnownFolder_GetId(folder, &folderId);
            ok(hr == S_OK, "failed to get folder id: 0x%08x\n", hr);
            ok(IsEqualGUID(&folderId, &FOLDERID_Windows)==TRUE, "invalid KNOWNFOLDERID returned\n");

            hr = IKnownFolder_Release(folder);
            ok(hr == S_OK, "failed to release KnownFolder instance: 0x%08x\n", hr);
        }

        folder = (IKnownFolder *)0xdeadbeef;
        hr = IKnownFolderManager_GetFolderByName(mgr, sNoSuch, &folder);
        ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
        ok(folder == NULL, "got %p\n", folder);

        for(i=0; i < ARRAY_SIZE(known_folder_found); ++i)
            known_folder_found[i] = FALSE;

        hr = IKnownFolderManager_GetFolderIds(mgr, &folders, &nCount);
        ok(hr == S_OK, "failed to get known folders: 0x%08x\n", hr);
        for(i=0;i<nCount;++i)
            check_known_folder(mgr, &folders[i]);

        for(i=0; i < ARRAY_SIZE(known_folder_found); ++i)
            if(!known_folder_found[i])
                trace("Known folder %s not found on current platform\n", known_folders[i].sFolderId);

        CoTaskMemFree(folders);

        /* test of registering new known folders */
        bRes = CreateDirectoryW(sExamplePath, NULL);
        ok(bRes, "cannot create example directory: %s\n", wine_dbgstr_w(sExamplePath));
        bRes = CreateDirectoryW(sExample2Path, NULL);
        ok(bRes, "cannot create example directory: %s\n", wine_dbgstr_w(sExample2Path));
        bRes = CreateDirectoryW(sSubFolderPath, NULL);
        ok(bRes, "cannot create example directory: %s\n", wine_dbgstr_w(sSubFolderPath));

        ZeroMemory(&kfDefinition, sizeof(kfDefinition));
        kfDefinition.category = KF_CATEGORY_PERUSER;
        kfDefinition.pszName = CoTaskMemAlloc(sizeof(sExample));
        lstrcpyW(kfDefinition.pszName, sExample);
        kfDefinition.pszDescription = CoTaskMemAlloc(sizeof(sExample));
        lstrcpyW(kfDefinition.pszDescription, sExample);
        kfDefinition.pszRelativePath = CoTaskMemAlloc(sizeof(sExamplePath));
        lstrcpyW(kfDefinition.pszRelativePath, sExamplePath);

        hr = IKnownFolderManager_RegisterFolder(mgr, &newFolderId, &kfDefinition);
        if(hr == HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED))
            win_skip("No permissions required to register custom known folder\n");
        else
        {
            ok(hr == S_OK, "failed to register known folder: 0x%08x\n", hr);
            if(SUCCEEDED(hr))
            {
                hr = IKnownFolderManager_GetFolder(mgr, &newFolderId, &folder);
                ok(hr == S_OK, "failed to get known folder: 0x%08x\n", hr);
                if(SUCCEEDED(hr))
                {
                    hr = IKnownFolder_GetCategory(folder, &cat);
                    ok(hr == S_OK, "failed to get folder category: hr=0x%0x\n", hr);
                    ok(cat == KF_CATEGORY_PERUSER, "invalid category returned: %d, while %d (KF_CATEGORY_PERUSER) expected\n", cat, KF_CATEGORY_PERUSER);

                    hr = IKnownFolder_GetId(folder, &folderId);
                    ok(hr == S_OK, "failed to get folder id: 0x%08x\n", hr);
                    ok(IsEqualGUID(&folderId, &newFolderId)==TRUE, "invalid KNOWNFOLDERID returned\n");

                    /* current path should be Temp\Example */
                    hr = IKnownFolder_GetPath(folder, 0, &folderPath);
                    ok(hr == S_OK, "failed to get path from known folder: 0x%08x\n", hr);
                    ok(lstrcmpiW(folderPath, sExamplePath)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sExamplePath));
                    CoTaskMemFree(folderPath);

                    /* register sub-folder and mark it as child of Example folder */
                    ZeroMemory(&kfSubDefinition, sizeof(kfSubDefinition));
                    kfSubDefinition.category = KF_CATEGORY_PERUSER;
                    kfSubDefinition.pszName = CoTaskMemAlloc(sizeof(sSubFolder));
                    lstrcpyW(kfSubDefinition.pszName, sSubFolder);
                    kfSubDefinition.pszDescription = CoTaskMemAlloc(sizeof(sSubFolder));
                    lstrcpyW(kfSubDefinition.pszDescription, sSubFolder);
                    kfSubDefinition.pszRelativePath = CoTaskMemAlloc(sizeof(sSubFolder));
                    lstrcpyW(kfSubDefinition.pszRelativePath, sSubFolder);
                    kfSubDefinition.fidParent = newFolderId;

                    hr = IKnownFolderManager_RegisterFolder(mgr, &subFolderId, &kfSubDefinition);
                    ok(hr == S_OK, "failed to register known folder: 0x%08x\n", hr);
                    if(SUCCEEDED(hr))
                    {

                        hr = IKnownFolderManager_GetFolder(mgr, &subFolderId, &subFolder);
                        ok(hr == S_OK, "failed to get known folder: 0x%08x\n", hr);
                        if(SUCCEEDED(hr))
                        {
                            /* check sub folder path */
                            hr = IKnownFolder_GetPath(subFolder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sSubFolderPath)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sSubFolderPath));
                            CoTaskMemFree(folderPath);


                            /* try to redirect Example to Temp\Example2  */
                            hr = IKnownFolderManager_Redirect(mgr, &newFolderId, NULL, 0, sExample2Path, 0, NULL, &errorMsg);
                            ok(hr == S_OK, "failed to redirect known folder: 0x%08x, errorMsg: %s\n", hr, wine_dbgstr_w(errorMsg));

                            /* verify */
                            hr = IKnownFolder_GetPath(folder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sExample2Path)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sExample2Path));
                            CoTaskMemFree(folderPath);

                            /* verify sub folder - it should fail now, as we redirected its parent folder, but we have no sub folder in new location */
                            hr = IKnownFolder_GetPath(subFolder, 0, &folderPath);
                            ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "unexpected value from GetPath(): 0x%08x\n", hr);
                            ok(folderPath==NULL, "invalid known folder path retrieved: \"%s\" when NULL pointer was expected\n", wine_dbgstr_w(folderPath));
                            CoTaskMemFree(folderPath);


                            /* set Example path to original. Using SetPath() is valid here, as it also uses redirection internally */
                            hr = IKnownFolder_SetPath(folder, 0, sExamplePath);
                            ok(hr == S_OK, "SetPath() failed: 0x%08x\n", hr);

                            /* verify */
                            hr = IKnownFolder_GetPath(folder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sExamplePath)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sExamplePath));
                            CoTaskMemFree(folderPath);


                            /* create sub folder in Temp\Example2 */
                            bRes = CreateDirectoryW(sSubFolder2Path, NULL);
                            ok(bRes, "cannot create example directory: %s\n", wine_dbgstr_w(sSubFolder2Path));

                            /* again perform that same redirection */
                            hr = IKnownFolderManager_Redirect(mgr, &newFolderId, NULL, 0, sExample2Path, 0, NULL, &errorMsg);
                            ok(hr == S_OK, "failed to redirect known folder: 0x%08x, errorMsg: %s\n", hr, wine_dbgstr_w(errorMsg));

                            /* verify sub folder. It should succeed now, as the required sub folder exists */
                            hr = IKnownFolder_GetPath(subFolder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sSubFolder2Path)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sSubFolder2Path));
                            CoTaskMemFree(folderPath);

                            /* remove newly created directory */
                            RemoveDirectoryW(sSubFolder2Path);

                            /* verify subfolder. It still succeeds, so Windows does not check folder presence each time */
                            hr = IKnownFolder_GetPath(subFolder, 0, &folderPath);
                            todo_wine
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            todo_wine
                            ok(lstrcmpiW(folderPath, sSubFolder2Path)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sSubFolder2Path));
                            CoTaskMemFree(folderPath);


                            /* set Example path to original */
                            hr = IKnownFolder_SetPath(folder, 0, sExamplePath);
                            ok(hr == S_OK, "SetPath() failed: 0x%08x\n", hr);

                            /* verify */
                            hr = IKnownFolder_GetPath(folder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sExamplePath)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sExamplePath));
                            CoTaskMemFree(folderPath);

                            /* verify sub folder */
                            hr = IKnownFolder_GetPath(subFolder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sSubFolderPath)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sSubFolderPath));
                            CoTaskMemFree(folderPath);


                            /* create sub folder in Temp\Example2 */
                            bRes = CreateDirectoryW(sSubFolder2Path, NULL);
                            ok(bRes, "cannot create example directory: %s\n", wine_dbgstr_w(sSubFolder2Path));

                            /* do that same redirection, but try to exclude sub-folder */
                            hr = IKnownFolderManager_Redirect(mgr, &newFolderId, NULL, 0, sExample2Path, 1, &subFolderId, &errorMsg);
                            ok(hr == S_OK, "failed to redirect known folder: 0x%08x, errorMsg: %s\n", hr, wine_dbgstr_w(errorMsg));

                            /* verify */
                            hr = IKnownFolder_GetPath(folder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sExample2Path)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sExample2Path));
                            CoTaskMemFree(folderPath);

                            /* verify sub folder. Unexpectedly, this path was also changed. So, exclusion seems to be ignored (Windows bug)? This test however will let us know, if this behavior is changed */
                            hr = IKnownFolder_GetPath(subFolder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sSubFolder2Path)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sSubFolder2Path));
                            CoTaskMemFree(folderPath);

                            /* remove newly created directory */
                            RemoveDirectoryW(sSubFolder2Path);


                            /* set Example path to original */
                            hr = IKnownFolder_SetPath(folder, 0, sExamplePath);
                            ok(hr == S_OK, "SetPath() failed: 0x%08x\n", hr);

                            /* verify */
                            hr = IKnownFolder_GetPath(folder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sExamplePath)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sExamplePath));
                            CoTaskMemFree(folderPath);

                            /* verify sub folder */
                            hr = IKnownFolder_GetPath(subFolder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sSubFolderPath)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sSubFolderPath));
                            CoTaskMemFree(folderPath);


                            /* do that same redirection again, but set it to copy content. It should also copy the sub folder, so checking it would succeed now */
                            hr = IKnownFolderManager_Redirect(mgr, &newFolderId, NULL, KF_REDIRECT_COPY_CONTENTS, sExample2Path, 0, NULL, &errorMsg);
                            ok(hr == S_OK, "failed to redirect known folder: 0x%08x, errorMsg: %s\n", hr, wine_dbgstr_w(errorMsg));

                            /* verify */
                            hr = IKnownFolder_GetPath(folder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sExample2Path)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sExample2Path));
                            CoTaskMemFree(folderPath);

                            /* verify sub folder */
                            hr = IKnownFolder_GetPath(subFolder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sSubFolder2Path)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sSubFolder2Path));
                            CoTaskMemFree(folderPath);

                            /* remove copied directory */
                            RemoveDirectoryW(sSubFolder2Path);


                            /* set Example path to original */
                            hr = IKnownFolder_SetPath(folder, 0, sExamplePath);
                            ok(hr == S_OK, "SetPath() failed: 0x%08x\n", hr);

                            /* verify */
                            hr = IKnownFolder_GetPath(folder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sExamplePath)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sExamplePath));
                            CoTaskMemFree(folderPath);

                            /* verify sub folder */
                            hr = IKnownFolder_GetPath(subFolder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sSubFolderPath)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sSubFolderPath));
                            CoTaskMemFree(folderPath);


                            /* redirect again, set it to copy content and remove originals */
                            hr = IKnownFolderManager_Redirect(mgr, &newFolderId, NULL, KF_REDIRECT_COPY_CONTENTS | KF_REDIRECT_DEL_SOURCE_CONTENTS, sExample2Path, 0, NULL, &errorMsg);
                            ok(hr == S_OK, "failed to redirect known folder: 0x%08x, errorMsg: %s\n", hr, wine_dbgstr_w(errorMsg));

                            /* verify */
                            hr = IKnownFolder_GetPath(folder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sExample2Path)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sExample2Path));
                            CoTaskMemFree(folderPath);

                            /* verify sub folder */
                            hr = IKnownFolder_GetPath(subFolder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sSubFolder2Path)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sSubFolder2Path));
                            CoTaskMemFree(folderPath);

                            /* check if original directory was really removed */
                            dwAttributes = GetFileAttributesW(sExamplePath);
                            ok(dwAttributes==INVALID_FILE_ATTRIBUTES, "directory should not exist, but has attributes: 0x%08x\n", dwAttributes );


                            /* redirect (with copy) to original path */
                            hr = IKnownFolderManager_Redirect(mgr, &newFolderId, NULL, KF_REDIRECT_COPY_CONTENTS,  sExamplePath, 0, NULL, &errorMsg);
                            ok(hr == S_OK, "failed to redirect known folder: 0x%08x, errorMsg: %s\n", hr, wine_dbgstr_w(errorMsg));

                            /* verify */
                            hr = IKnownFolder_GetPath(folder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sExamplePath)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sExamplePath));
                            CoTaskMemFree(folderPath);

                            /* verify sub folder */
                            hr = IKnownFolder_GetPath(subFolder, 0, &folderPath);
                            ok(hr == S_OK, "failed to get known folder path: 0x%08x\n", hr);
                            ok(lstrcmpiW(folderPath, sSubFolderPath)==0, "invalid known folder path retrieved: \"%s\" when \"%s\" was expected\n", wine_dbgstr_w(folderPath), wine_dbgstr_w(sSubFolderPath));
                            CoTaskMemFree(folderPath);

                            /* check shell utility functions */
                            if(!pSHGetKnownFolderPath || !pSHSetKnownFolderPath)
                                todo_wine
                                win_skip("cannot get SHGet/SetKnownFolderPath routines\n");
                            else
                            {
                                /* try to get current known folder path */
                                hr = pSHGetKnownFolderPath(&newFolderId, 0, NULL, &folderPath);
                                todo_wine
                                ok(hr==S_OK, "cannot get known folder path: hr=0x%0x\n", hr);
                                todo_wine
                                ok(lstrcmpW(folderPath, sExamplePath)==0, "invalid path returned: %s\n", wine_dbgstr_w(folderPath));

                                /* set it to new value */
                                hr = pSHSetKnownFolderPath(&newFolderId, 0, NULL, sExample2Path);
                                todo_wine
                                ok(hr==S_OK, "cannot set known folder path: hr=0x%0x\n", hr);

                                /* check if it changed */
                                hr = pSHGetKnownFolderPath(&newFolderId, 0, NULL, &folderPath);
                                todo_wine
                                ok(hr==S_OK, "cannot get known folder path: hr=0x%0x\n", hr);
                                todo_wine
                                ok(lstrcmpW(folderPath, sExample2Path)==0, "invalid path returned: %s\n", wine_dbgstr_w(folderPath));

                                /* set it back */
                                hr = pSHSetKnownFolderPath(&newFolderId, 0, NULL, sExamplePath);
                                todo_wine
                                ok(hr==S_OK, "cannot set known folder path: hr=0x%0x\n", hr);
                            }

                            IKnownFolder_Release(subFolder);
                        }

                        hr = IKnownFolderManager_UnregisterFolder(mgr, &subFolderId);
                        ok(hr == S_OK, "failed to unregister folder: 0x%08x\n", hr);
                    }

                    FreeKnownFolderDefinitionFields(&kfSubDefinition);

                    hr = IKnownFolder_Release(folder);
                    ok(hr == S_OK, "failed to release KnownFolder instance: 0x%08x\n", hr);

                    /* update the folder */
                    CoTaskMemFree(kfDefinition.pszName);
                    kfDefinition.pszName = CoTaskMemAlloc(sizeof(sExample2));
                    lstrcpyW(kfDefinition.pszName, sExample2);
                    hr = IKnownFolderManager_RegisterFolder(mgr, &newFolderId, &kfDefinition);
                    ok(hr == S_OK, "failed to re-register known folder: 0x%08x\n", hr);

                    hr = IKnownFolderManager_GetFolder(mgr, &newFolderId, &folder);
                    ok(hr == S_OK, "failed to get known folder: 0x%08x\n", hr);

                    hr = IKnownFolder_GetFolderDefinition(folder, &kfSubDefinition);
                    ok(hr == S_OK, "failed to get folder definition: 0x%08x\n", hr);
                    ok(!memcmp(kfDefinition.pszName, kfSubDefinition.pszName, sizeof(sExample2)),
                            "Got wrong updated name: %s\n", wine_dbgstr_w(kfSubDefinition.pszName));

                    FreeKnownFolderDefinitionFields(&kfSubDefinition);

                    hr = IKnownFolder_Release(folder);
                    ok(hr == S_OK, "failed to release KnownFolder instance: 0x%08x\n", hr);
                }

                hr = IKnownFolderManager_UnregisterFolder(mgr, &newFolderId);
                ok(hr == S_OK, "failed to unregister folder: 0x%08x\n", hr);
            }
        }
        FreeKnownFolderDefinitionFields(&kfDefinition);

        RemoveDirectoryW(sSubFolder2Path);
        RemoveDirectoryW(sSubFolderPath);
        RemoveDirectoryW(sExamplePath);
        RemoveDirectoryW(sExample2Path);

        hr = IKnownFolderManager_Release(mgr);
        ok(hr == S_OK, "failed to release KnownFolderManager instance: 0x%08x\n", hr);
    }
    CoUninitialize();
}

Referenced by START_TEST().

test_NonExistentPath()

static void test_NonExistentPath ( void  )

static

Definition at line 1773 of file shellpath.c.

{
    static const char userShellFolders[] =
     "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders";
    char originalPath[MAX_PATH], modifiedPath[MAX_PATH];
    HKEY key;

    if (!pSHGetFolderPathA) return;
    if (!pSHGetFolderLocation) return;
    if (!pSHGetSpecialFolderPathA) return;
    if (!pSHGetSpecialFolderLocation) return;
    if (!pSHFileOperationA) return;
    if (shellVersion.dwMajorVersion < 5) return;

    if (!RegOpenKeyExA(HKEY_CURRENT_USER, userShellFolders, 0, KEY_ALL_ACCESS,
     &key))
    {
        DWORD len, type;

        len = sizeof(originalPath);
        if (!RegQueryValueExA(key, "Favorites", NULL, &type,
         (LPBYTE)&originalPath, &len))
        {
            size_t len = strlen(originalPath);

            memcpy(modifiedPath, originalPath, len);
            modifiedPath[len++] = '2';
            modifiedPath[len++] = '\0';
            trace("Changing CSIDL_FAVORITES to %s\n", modifiedPath);
            if (!RegSetValueExA(key, "Favorites", 0, type,
             (LPBYTE)modifiedPath, len))
            {
                char buffer[MAX_PATH+20];
                STARTUPINFOA startup;
                PROCESS_INFORMATION info;

                sprintf(buffer, "%s tests/shellpath.c 1", selfname);
                memset(&startup, 0, sizeof(startup));
                startup.cb = sizeof(startup);
                startup.dwFlags = STARTF_USESHOWWINDOW;
                startup.wShowWindow = SW_SHOWNORMAL;
                CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL,
                 &startup, &info);
                winetest_wait_child_process( info.hProcess );

                /* restore original values: */
                trace("Restoring CSIDL_FAVORITES to %s\n", originalPath);
                RegSetValueExA(key, "Favorites", 0, type, (LPBYTE) originalPath,
                 strlen(originalPath) + 1);
                RegFlushKey(key);

                sprintf(buffer, "%s tests/shellpath.c 2", selfname);
                memset(&startup, 0, sizeof(startup));
                startup.cb = sizeof(startup);
                startup.dwFlags = STARTF_USESHOWWINDOW;
                startup.wShowWindow = SW_SHOWNORMAL;
                CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL,
                 &startup, &info);
                ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0,
                 "child process termination\n");
            }
        }
        else skip("RegQueryValueExA(key, Favorites, ...) failed\n");
        if (key)
            RegCloseKey(key);
    }
    else skip("RegOpenKeyExA(HKEY_CURRENT_USER, %s, ...) failed\n", userShellFolders);
}

Referenced by START_TEST().

test_parameters()

static void test_parameters ( void  )

static

Definition at line 1313 of file shellpath.c.

{
    LPITEMIDLIST pidl = NULL;
    char path[MAX_PATH];
    HRESULT hr;

    if (pSHGetFolderLocation)
    {
        /* check a bogus CSIDL: */
        pidl = NULL;
        hr = pSHGetFolderLocation(NULL, 0xeeee, NULL, 0, &pidl);
        ok(hr == E_INVALIDARG, "got 0x%08x, expected E_INVALIDARG\n", hr);
        if (hr == S_OK) IMalloc_Free(pMalloc, pidl);

        /* check a bogus user token: */
        pidl = NULL;
        hr = pSHGetFolderLocation(NULL, CSIDL_FAVORITES, (HANDLE)2, 0, &pidl);
        ok(hr == E_FAIL || hr == E_HANDLE, "got 0x%08x, expected E_FAIL or E_HANDLE\n", hr);
        if (hr == S_OK) IMalloc_Free(pMalloc, pidl);

        /* a NULL pidl pointer crashes, so don't test it */
    }

    if (pSHGetSpecialFolderLocation)
    {
        if (0)
            /* crashes */
            SHGetSpecialFolderLocation(NULL, 0, NULL);

        hr = pSHGetSpecialFolderLocation(NULL, 0xeeee, &pidl);
        ok(hr == E_INVALIDARG, "got returned 0x%08x\n", hr);
    }

    if (pSHGetFolderPathA)
    {
        /* expect 2's a bogus handle, especially since we didn't open it */
        hr = pSHGetFolderPathA(NULL, CSIDL_DESKTOP, (HANDLE)2, SHGFP_TYPE_DEFAULT, path);
        ok(hr == E_FAIL || hr == E_HANDLE || /* Vista and 2k8 */
           broken(hr == S_OK), /* W2k and Me */ "got 0x%08x, expected E_FAIL\n", hr);

        hr = pSHGetFolderPathA(NULL, 0xeeee, NULL, SHGFP_TYPE_DEFAULT, path);
        ok(hr == E_INVALIDARG, "got 0x%08x, expected E_INVALIDARG\n", hr);
    }

    if (pSHGetSpecialFolderPathA)
    {
        BOOL ret;

        if (0)
           pSHGetSpecialFolderPathA(NULL, NULL, CSIDL_BITBUCKET, FALSE);

        /* odd but true: calling with a NULL path still succeeds if it's a real
         * dir (on some windows platform).  on winME it generates exception.
         */
        ret = pSHGetSpecialFolderPathA(NULL, path, CSIDL_PROGRAMS, FALSE);
        ok(ret, "got %d\n", ret);

        ret = pSHGetSpecialFolderPathA(NULL, path, 0xeeee, FALSE);
        ok(!ret, "got %d\n", ret);
    }
}

Referenced by START_TEST().

test_PathYetAnotherMakeUniqueName()

static void test_PathYetAnotherMakeUniqueName ( void  )

static

Definition at line 2707 of file shellpath.c.

{
    static const WCHAR shortW[] = {'f','i','l','e','.','t','s','t',0};
    static const WCHAR short2W[] = {'f','i','l','e',' ','(','2',')','.','t','s','t',0};
    static const WCHAR tmpW[] = {'t','m','p',0};
    static const WCHAR longW[] = {'n','a','m','e',0};
    static const WCHAR long2W[] = {'n','a','m','e',' ','(','2',')',0};
    WCHAR nameW[MAX_PATH], buffW[MAX_PATH], pathW[MAX_PATH];
    HANDLE file;
    BOOL ret;

    if (!pPathYetAnotherMakeUniqueName)
    {
        win_skip("PathYetAnotherMakeUniqueName() is not available.\n");
        return;
    }

if (0)
{
    /* crashes on Windows */
    ret = pPathYetAnotherMakeUniqueName(NULL, NULL, NULL, NULL);
    ok(!ret, "got %d\n", ret);

    ret = pPathYetAnotherMakeUniqueName(nameW, NULL, NULL, NULL);
    ok(!ret, "got %d\n", ret);
}

    GetTempPathW(ARRAY_SIZE(pathW), pathW);

    /* Using short name only first */
    nameW[0] = 0;
    ret = pPathYetAnotherMakeUniqueName(nameW, pathW, shortW, NULL);
    ok(ret, "got %d\n", ret);
    lstrcpyW(buffW, pathW);
    lstrcatW(buffW, shortW);
    ok(!lstrcmpW(nameW, buffW), "got %s, expected %s\n", wine_dbgstr_w(nameW), wine_dbgstr_w(buffW));

    /* now create a file with this name and get next name */
    file = CreateFileW(nameW, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_FLAG_DELETE_ON_CLOSE, NULL);
    ok(file != NULL, "got %p\n", file);

    nameW[0] = 0;
    ret = pPathYetAnotherMakeUniqueName(nameW, pathW, shortW, NULL);
    ok(ret, "got %d\n", ret);
    lstrcpyW(buffW, pathW);
    lstrcatW(buffW, short2W);
    ok(!lstrcmpW(nameW, buffW), "got %s, expected %s\n", wine_dbgstr_w(nameW), wine_dbgstr_w(buffW));

    CloseHandle(file);

    /* Using short and long */
    nameW[0] = 0;
    ret = pPathYetAnotherMakeUniqueName(nameW, pathW, tmpW, longW);
    ok(ret, "got %d\n", ret);
    lstrcpyW(buffW, pathW);
    lstrcatW(buffW, longW);
    ok(!lstrcmpW(nameW, buffW), "got %s, expected %s\n", wine_dbgstr_w(nameW), wine_dbgstr_w(buffW));

    file = CreateFileW(nameW, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_FLAG_DELETE_ON_CLOSE, NULL);
    ok(file != NULL, "got %p\n", file);

    nameW[0] = 0;
    ret = pPathYetAnotherMakeUniqueName(nameW, pathW, tmpW, longW);
    ok(ret, "got %d\n", ret);
    lstrcpyW(buffW, pathW);
    lstrcatW(buffW, long2W);
    ok(!lstrcmpW(nameW, buffW), "got %s, expected %s\n", wine_dbgstr_w(nameW), wine_dbgstr_w(buffW));

    CloseHandle(file);

    /* Using long only */
    nameW[0] = 0;
    ret = pPathYetAnotherMakeUniqueName(nameW, pathW, NULL, longW);
    ok(ret, "got %d\n", ret);
    lstrcpyW(buffW, pathW);
    lstrcatW(buffW, longW);
    ok(!lstrcmpW(nameW, buffW), "got %s, expected %s\n", wine_dbgstr_w(nameW), wine_dbgstr_w(buffW));
}

Referenced by START_TEST().

test_PidlTypes()

static void test_PidlTypes ( void  )

static

Definition at line 1563 of file shellpath.c.

{
    /* Desktop */
    test_SHGetFolderPath(FALSE, CSIDL_DESKTOP);
    test_SHGetSpecialFolderPath(FALSE, CSIDL_DESKTOP);

    test_ShellValues(requiredShellValues, ARRAY_SIZE(requiredShellValues), FALSE);
    test_ShellValues(optionalShellValues, ARRAY_SIZE(optionalShellValues), TRUE);
}

Referenced by START_TEST().

test_ShellValues()

static void test_ShellValues ( const struct shellExpectedValues  testEntries[], int  numEntries, BOOL  optional  )

static

Definition at line 1458 of file shellpath.c.

{
    int i;

    for (i = 0; i < numEntries; i++)
    {
        BYTE type;
        int j;
        BOOL foundTypeMatch = FALSE;

        if (pSHGetFolderLocation)
        {
            type = testSHGetFolderLocation(testEntries[i].folder);
            for (j = 0; !foundTypeMatch && j < testEntries[i].numTypes; j++)
                if (testEntries[i].types[j] == type)
                    foundTypeMatch = TRUE;
            ok(foundTypeMatch || optional || broken(type == 0xff) /* Win9x */,
             "%s has unexpected type %d (0x%02x)\n",
             getFolderName(testEntries[i].folder), type, type);
        }
        type = testSHGetSpecialFolderLocation(testEntries[i].folder);
        for (j = 0, foundTypeMatch = FALSE; !foundTypeMatch &&
         j < testEntries[i].numTypes; j++)
            if (testEntries[i].types[j] == type)
                foundTypeMatch = TRUE;
        ok(foundTypeMatch || optional || broken(type == 0xff) /* Win9x */,
         "%s has unexpected type %d (0x%02x)\n",
         getFolderName(testEntries[i].folder), type, type);
        switch (type)
        {
            case PT_FOLDER:
            case PT_DRIVE:
            case PT_DRIVE2:
            case PT_IESPECIAL2:
                test_SHGetFolderPath(optional, testEntries[i].folder);
                test_SHGetSpecialFolderPath(optional, testEntries[i].folder);
                break;
        }
    }
}

Referenced by test_PidlTypes().

test_SHGetFolderPath()

static void test_SHGetFolderPath ( BOOL  optional, int  folder  )

static

Definition at line 1431 of file shellpath.c.

{
    char path[MAX_PATH];
    HRESULT hr;

    if (!pSHGetFolderPathA) return;

    hr = pSHGetFolderPathA(NULL, folder, NULL, SHGFP_TYPE_CURRENT, path);
    ok(hr == S_OK || optional,
     "SHGetFolderPathA(NULL, %s, NULL, SHGFP_TYPE_CURRENT, path) failed: 0x%08x\n", getFolderName(folder), hr);
}

Referenced by test_PidlTypes(), and test_ShellValues().

test_SHGetFolderPathEx()

static void test_SHGetFolderPathEx ( void  )

static

Definition at line 1842 of file shellpath.c.

{
    WCHAR buffer[MAX_PATH], *path, *path2;
    unsigned int i;
    HRESULT hr;
    DWORD len;

    if (!pSHGetKnownFolderPath || !pSHGetFolderPathEx)
    {
        win_skip("SHGetKnownFolderPath or SHGetFolderPathEx not available\n");
        return;
    }

if (0) { /* crashes */
    hr = pSHGetKnownFolderPath(&FOLDERID_Desktop, 0, NULL, NULL);
    ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
}
    /* non-existent folder id */
    path = (void *)0xdeadbeef;
    hr = pSHGetKnownFolderPath(&IID_IOleObject, 0, NULL, &path);
    ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
    ok(path == NULL, "got %p\n", path);

    path = NULL;
    hr = pSHGetKnownFolderPath(&FOLDERID_Desktop, KF_FLAG_DEFAULT_PATH, NULL, &path);
    ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
    ok(path != NULL, "expected path != NULL\n");
    CoTaskMemFree(path);

    for (i = 0; i < ARRAY_SIZE(known_folders); ++i)
    {
        const KNOWNFOLDERID *folder_id = known_folders[i].folderId;

        path = NULL;
        hr = pSHGetKnownFolderPath(folder_id, KF_FLAG_DEFAULT, NULL, &path);
        if (FAILED(hr))
            continue;
        ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
        ok(path != NULL, "expected path != NULL\n");

        path2 = NULL;
        hr = pSHGetKnownFolderPath(folder_id, KF_FLAG_SIMPLE_IDLIST, NULL, &path2);
        ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
        ok(path2 != NULL, "expected path != NULL\n");
        ok(!lstrcmpiW(path, path2), "expected equal paths: %s, %s\n", wine_dbgstr_w(path), wine_dbgstr_w(path2));
        CoTaskMemFree(path2);

        path2 = NULL;
        hr = pSHGetKnownFolderPath(folder_id, KF_FLAG_DONT_UNEXPAND, NULL, &path2);
        ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
        ok(path2 != NULL, "expected path != NULL\n");
        ok(!lstrcmpiW(path, path2), "expected equal paths: %s, %s\n", wine_dbgstr_w(path), wine_dbgstr_w(path2));
        CoTaskMemFree(path2);

        path2 = NULL;
        hr = pSHGetKnownFolderPath(folder_id, KF_FLAG_SIMPLE_IDLIST | KF_FLAG_DONT_UNEXPAND, NULL, &path2);
        ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
        ok(path2 != NULL, "expected path != NULL\n");
        ok(!lstrcmpiW(path, path2), "expected equal paths: %s, %s\n", wine_dbgstr_w(path), wine_dbgstr_w(path2));
        CoTaskMemFree(path2);

        CoTaskMemFree(path);
    }

    path = NULL;
    hr = pSHGetKnownFolderPath(&FOLDERID_Desktop, 0, NULL, &path);
    ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
    ok(path != NULL, "expected path != NULL\n");

    hr = pSHGetFolderPathEx(&FOLDERID_Desktop, 0, NULL, buffer, MAX_PATH);
    ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
    ok(!lstrcmpiW(path, buffer), "expected equal paths\n");
    len = lstrlenW(buffer);
    CoTaskMemFree(path);

    hr = pSHGetFolderPathEx(&FOLDERID_Desktop, 0, NULL, buffer, 0);
    ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);

if (0) { /* crashes */
    hr = pSHGetFolderPathEx(&FOLDERID_Desktop, 0, NULL, NULL, len + 1);
    ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);

    hr = pSHGetFolderPathEx(NULL, 0, NULL, buffer, MAX_PATH);
    ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
}
    hr = pSHGetFolderPathEx(&FOLDERID_Desktop, 0, NULL, buffer, len);
    ok(hr == E_NOT_SUFFICIENT_BUFFER, "expected E_NOT_SUFFICIENT_BUFFER, got 0x%08x\n", hr);

    hr = pSHGetFolderPathEx(&FOLDERID_Desktop, 0, NULL, buffer, len + 1);
    ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
}

Referenced by START_TEST().

test_SHGetKnownFolderIDList()

static void test_SHGetKnownFolderIDList ( void  )

static

Definition at line 2786 of file shellpath.c.

{
    PIDLIST_ABSOLUTE pidl;
    HRESULT hr;

    if (!pSHGetKnownFolderIDList)
    {
        win_skip("SHGetKnownFolderIDList is not available.\n");
        return;
    }

    hr = pSHGetKnownFolderIDList(NULL, 0, NULL, NULL);
    ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);

if (0) { /* crashes on native */
    pidl = (void*)0xdeadbeef;
    hr = pSHGetKnownFolderIDList(NULL, 0, NULL, &pidl);
}
    /* not a known folder */
    pidl = (void*)0xdeadbeef;
    hr = pSHGetKnownFolderIDList(&IID_IUnknown, 0, NULL, &pidl);
    ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
    ok(pidl == NULL, "got %p\n", pidl);

    hr = pSHGetKnownFolderIDList(&FOLDERID_Desktop, 0, NULL, NULL);
    ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);

    pidl = (void*)0xdeadbeef;
    hr = pSHGetKnownFolderIDList(&FOLDERID_Desktop, 0, NULL, &pidl);
    ok(hr == S_OK, "SHGetKnownFolderIDList failed: 0x%08x\n", hr);
    ok(ILIsEmpty(pidl), "pidl should be empty.\n");
    ok(pidl->mkid.cb == 0, "get wrong value: %d\n", pidl->mkid.cb);
    ILFree(pidl);

    pidl = (void*)0xdeadbeef;
    hr = pSHGetKnownFolderIDList(&FOLDERID_Desktop, KF_FLAG_NO_ALIAS, NULL, &pidl);
    ok(hr == S_OK, "SHGetKnownFolderIDList failed: 0x%08x\n", hr);
    todo_wine ok(!ILIsEmpty(pidl), "pidl should not be empty.\n");
    todo_wine ok(pidl->mkid.cb == 20, "get wrong value: %d\n", pidl->mkid.cb);
    ILFree(pidl);

    pidl = (void*)0xdeadbeef;
    hr = pSHGetKnownFolderIDList(&FOLDERID_Documents, 0, NULL, &pidl);
    ok(hr == S_OK, "SHGetKnownFolderIDList failed: 0x%08x\n", hr);
    ok(!ILIsEmpty(pidl), "pidl should not be empty.\n");
    ok(pidl->mkid.cb == 20, "get wrong value: %d\n", pidl->mkid.cb);
    ILFree(pidl);

    pidl = (void*)0xdeadbeef;
    hr = pSHGetKnownFolderIDList(&FOLDERID_Documents, KF_FLAG_NO_ALIAS, NULL, &pidl);
    ok(hr == S_OK, "SHGetKnownFolderIDList failed: 0x%08x\n", hr);
    ok(!ILIsEmpty(pidl), "pidl should not be empty.\n");
    ok(pidl->mkid.cb == 20, "get wrong value: %d\n", pidl->mkid.cb);
    ILFree(pidl);
}

Referenced by START_TEST().

test_SHGetSpecialFolderPath()

static void test_SHGetSpecialFolderPath ( BOOL  optional, int  folder  )

static

Definition at line 1443 of file shellpath.c.

{
    char path[MAX_PATH];
    BOOL ret;

    if (!pSHGetSpecialFolderPathA) return;

    ret = pSHGetSpecialFolderPathA(NULL, path, folder, FALSE);
    if (ret && winetest_interactive)
        printf("%s: %s\n", getFolderName(folder), path);
    ok(ret || optional,
     "SHGetSpecialFolderPathA(NULL, path, %s, FALSE) failed\n",
     getFolderName(folder));
}

Referenced by test_PidlTypes(), and test_ShellValues().

testSHGetFolderLocation()

static BYTE testSHGetFolderLocation ( int  folder )

static

Definition at line 1376 of file shellpath.c.

{
    LPITEMIDLIST pidl;
    HRESULT hr;
    BYTE ret = 0xff;

    /* treat absence of function as success */
    if (!pSHGetFolderLocation) return TRUE;

    pidl = NULL;
    hr = pSHGetFolderLocation(NULL, folder, NULL, 0, &pidl);
    if (hr == S_OK)
    {
        if (pidl)
        {
            LPITEMIDLIST pidlLast = pILFindLastID(pidl);

            ok(pidlLast != NULL, "%s: ILFindLastID failed\n",
             getFolderName(folder));
            if (pidlLast)
                ret = pidlLast->mkid.abID[0];
            IMalloc_Free(pMalloc, pidl);
        }
    }
    return ret;
}

Referenced by test_ShellValues().

testSHGetSpecialFolderLocation()

static BYTE testSHGetSpecialFolderLocation ( int  folder )

static

Definition at line 1404 of file shellpath.c.

{
    LPITEMIDLIST pidl;
    HRESULT hr;
    BYTE ret = 0xff;

    /* treat absence of function as success */
    if (!pSHGetSpecialFolderLocation) return TRUE;

    pidl = NULL;
    hr = pSHGetSpecialFolderLocation(NULL, folder, &pidl);
    if (hr == S_OK)
    {
        if (pidl)
        {
            LPITEMIDLIST pidlLast = pILFindLastID(pidl);

            ok(pidlLast != NULL,
                "%s: ILFindLastID failed\n", getFolderName(folder));
            if (pidlLast)
                ret = pidlLast->mkid.abID[0];
            IMalloc_Free(pMalloc, pidl);
        }
    }
    return ret;
}

Referenced by test_ShellValues().

testSystemDir()

static void testSystemDir ( void  )

static

Definition at line 1651 of file shellpath.c.

{
    char systemShellPath[MAX_PATH], systemDir[MAX_PATH], systemDirx86[MAX_PATH];

    if (!pSHGetSpecialFolderPathA) return;

    GetSystemDirectoryA(systemDir, sizeof(systemDir));
    myPathRemoveBackslashA(systemDir);
    if (pSHGetSpecialFolderPathA(NULL, systemShellPath, CSIDL_SYSTEM, FALSE))
    {
        myPathRemoveBackslashA(systemShellPath);
        ok(!lstrcmpiA(systemDir, systemShellPath),
         "GetSystemDirectory returns %s SHGetSpecialFolderPath returns %s\n",
         systemDir, systemShellPath);
    }

    if (!pGetSystemWow64DirectoryA || !pGetSystemWow64DirectoryA(systemDirx86, sizeof(systemDirx86)))
        GetSystemDirectoryA(systemDirx86, sizeof(systemDirx86));
    myPathRemoveBackslashA(systemDirx86);
    if (pSHGetSpecialFolderPathA(NULL, systemShellPath, CSIDL_SYSTEMX86, FALSE))
    {
        myPathRemoveBackslashA(systemShellPath);
        ok(!lstrcmpiA(systemDirx86, systemShellPath) || broken(!lstrcmpiA(systemDir, systemShellPath)),
         "GetSystemDirectory returns %s SHGetSpecialFolderPath returns %s\n",
         systemDir, systemShellPath);
    }
}

Referenced by START_TEST().

testWinDir()

static void testWinDir ( void  )

static

Definition at line 1630 of file shellpath.c.

{
    char windowsShellPath[MAX_PATH], windowsDir[MAX_PATH] = { 0 };

    if (!pSHGetSpecialFolderPathA) return;

    if (pSHGetSpecialFolderPathA(NULL, windowsShellPath, CSIDL_WINDOWS, FALSE))
    {
        myPathRemoveBackslashA(windowsShellPath);
        GetWindowsDirectoryA(windowsDir, sizeof(windowsDir));
        myPathRemoveBackslashA(windowsDir);
        ok(!lstrcmpiA(windowsDir, windowsShellPath),
         "GetWindowsDirectory returns %s SHGetSpecialFolderPath returns %s\n",
         windowsDir, windowsShellPath);
    }
}

Referenced by START_TEST().

UINT()

static UINT ( WINAPI *  pGetSystemWow64DirectoryA )

static

Variable Documentation

_FOLDERID_CredentialManager

const GUID _FOLDERID_CredentialManager = {0x915221FB, 0x9EFE, 0x4BDA, {0x8F, 0xD7, 0xF7, 0x8D, 0xCA, 0x77, 0x4F, 0x87} }

static

Definition at line 317 of file shellpath.c.

_FOLDERID_CryptoKeys

const GUID _FOLDERID_CryptoKeys = {0xB88F4DAA, 0xE7BD, 0x49A9, {0xB7, 0x4D, 0x02, 0x88, 0x5A, 0x5D, 0xC7, 0x65} }

static

Definition at line 314 of file shellpath.c.

_FOLDERID_DpapiKeys

const GUID _FOLDERID_DpapiKeys = {0x10C07CD0, 0xEF91, 0x4567, {0xB8, 0x50, 0x44, 0x8B, 0x77, 0xCB, 0x37, 0xF9} }

static

Definition at line 315 of file shellpath.c.

_FOLDERID_SystemCertificates

const GUID _FOLDERID_SystemCertificates = {0x54EED2E0, 0xE7CA, 0x4FDB, {0x91, 0x48, 0x0F, 0x42, 0x47, 0x29, 0x1C, 0xFA} }

static

Definition at line 316 of file shellpath.c.

base

char base[MAX_PATH]

static

Definition at line 1682 of file shellpath.c.

BOOL

LPITEMIDLIST* static BOOL

Definition at line 91 of file shellpath.c.

CLSID_CommonDocuments

GUID CLSID_CommonDocuments = { 0x0000000c, 0x0000, 0x0000, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0x1a } }

static

Definition at line 79 of file shellpath.c.

Referenced by test_GUIDs().

controlPanelType

const BYTE controlPanelType[] = { PT_SHELLEXT, PT_GUID, PT_CPL }

static

Definition at line 106 of file shellpath.c.

DWORD

DWORD

Definition at line 88 of file shellpath.c.

favoritesType

const BYTE favoritesType[] = { PT_FOLDER, PT_FOLDERW, 0, PT_IESPECIAL2 }

static

Definition at line 108 of file shellpath.c.

folderOrSpecialType

const BYTE folderOrSpecialType[] = { PT_FOLDER, PT_IESPECIAL2 }

static

Definition at line 109 of file shellpath.c.

folderType

const BYTE folderType[] = { PT_FOLDER, PT_FOLDERW }

static

Definition at line 107 of file shellpath.c.

guidType

const BYTE guidType[] = { PT_GUID }

static

Definition at line 105 of file shellpath.c.

HANDLE

HANDLE

Definition at line 88 of file shellpath.c.

Referenced by _SHRegisterUserShellFolders().

ieSpecialType

const BYTE ieSpecialType[] = { PT_IESPECIAL2 }

static

Definition at line 114 of file shellpath.c.

int

int

Definition at line 88 of file shellpath.c.

known_folder_found

BOOL known_folder_found[ARRAY_SIZE(known_folders)]

Definition at line 1311 of file shellpath.c.

Referenced by check_known_folder(), and test_knownFolders().

known_folders

const struct knownFolderDef known_folders[]

static

Definition at line 343 of file shellpath.c.

Referenced by check_known_folder(), test_knownFolders(), and test_SHGetFolderPathEx().

LPSTR

LPITEMIDLIST* static LPSTR

Definition at line 88 of file shellpath.c.

Referenced by PathCleanupSpec().

LPWSTR

LPWSTR

Definition at line 99 of file shellpath.c.

myARGC

int myARGC

static

Definition at line 1680 of file shellpath.c.

Referenced by init(), and START_TEST().

myARGV

char** myARGV

static

Definition at line 1681 of file shellpath.c.

Referenced by init(), and START_TEST().

optionalShellValues

const struct shellExpectedValues optionalShellValues[]

static

Definition at line 142 of file shellpath.c.

Referenced by test_PidlTypes().

PCWSTR

PCWSTR

Definition at line 100 of file shellpath.c.

personalType

const BYTE personalType[]

static

Initial value:

= { PT_FOLDER, PT_GUID, PT_DRIVE, 0xff ,
 PT_IESPECIAL2 , 0 , PT_SHELLEXT  }

Definition at line 110 of file shellpath.c.

pMalloc

LPMALLOC pMalloc

static

Definition at line 104 of file shellpath.c.

Referenced by doChild(), loadShell32(), matchGUID(), test_parameters(), testSHGetFolderLocation(), and testSHGetSpecialFolderLocation().

printersType

const BYTE printersType[] = { PT_YAGUID, PT_SHELLEXT, 0x71 }

static

Definition at line 113 of file shellpath.c.

PWSTR

PWSTR* static PWSTR

Definition at line 98 of file shellpath.c.

requiredShellValues

const struct shellExpectedValues requiredShellValues[]

static

Initial value:

= {
 DECLARE_TYPE(CSIDL_BITBUCKET, guidType),
 DECLARE_TYPE(CSIDL_CONTROLS, controlPanelType),
 DECLARE_TYPE(CSIDL_COOKIES, folderType),
 DECLARE_TYPE(CSIDL_DESKTOPDIRECTORY, folderType),
 DECLARE_TYPE(CSIDL_DRIVES, guidType),
 DECLARE_TYPE(CSIDL_FAVORITES, favoritesType),
 DECLARE_TYPE(CSIDL_FONTS, folderOrSpecialType),

 DECLARE_TYPE(CSIDL_INTERNET, guidType),
 DECLARE_TYPE(CSIDL_NETHOOD, folderType),
 DECLARE_TYPE(CSIDL_NETWORK, guidType),
 DECLARE_TYPE(CSIDL_PERSONAL, personalType),
 DECLARE_TYPE(CSIDL_PRINTERS, printersType),
 DECLARE_TYPE(CSIDL_PRINTHOOD, folderType),
 DECLARE_TYPE(CSIDL_PROGRAMS, folderType),
 DECLARE_TYPE(CSIDL_RECENT, folderOrSpecialType),
 DECLARE_TYPE(CSIDL_SENDTO, folderType),
 DECLARE_TYPE(CSIDL_STARTMENU, folderType),
 DECLARE_TYPE(CSIDL_STARTUP, folderType),
 DECLARE_TYPE(CSIDL_TEMPLATES, folderType),
}

Definition at line 118 of file shellpath.c.

Referenced by test_PidlTypes().

selfname

char selfname[MAX_PATH]

static

Definition at line 1683 of file shellpath.c.

Referenced by init(), and test_NonExistentPath().

shellExtType

const BYTE shellExtType[] = { PT_SHELLEXT }

static

Definition at line 115 of file shellpath.c.

shellVersion

PIDLIST_ABSOLUTE* static DLLVERSIONINFO shellVersion = { 0 }

static

Definition at line 103 of file shellpath.c.

Referenced by loadShell32(), and test_NonExistentPath().

UINT

UINT

Definition at line 96 of file shellpath.c.

workgroupType

const BYTE workgroupType[] = { PT_WORKGRP }

static

Definition at line 116 of file shellpath.c.