/*
 * Unit tests for IShellDispatch
 *
 * Copyright 2010 Alexander Morozov for Etersoft
 *
 * 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
 */

#define COBJMACROS
#define NONAMELESSUNION
#define NONAMELESSSTRUCT

#include "shldisp.h"
#include "shlobj.h"
#include "shlwapi.h"
#include "winsvc.h"
#include "wine/test.h"

#include "initguid.h"

#define EXPECT_HR(hr,hr_exp) \
    ok(hr == hr_exp, "got 0x%08x, expected 0x%08x\n", hr, hr_exp)

#define EXPECT_REF(obj,ref) _expect_ref((IUnknown *)obj, ref, __LINE__)
static void _expect_ref(IUnknown *obj, ULONG ref, int line)
{
    ULONG rc;
    IUnknown_AddRef(obj);
    rc = IUnknown_Release(obj);
    ok_(__FILE__,line)(rc == ref, "Unexpected refcount %d, expected %d\n", rc, ref);
}

static const WCHAR winetestW[] = {'w','i','n','e','t','e','s','t',0};

static HRESULT (WINAPI *pSHGetNameFromIDList)(PCIDLIST_ABSOLUTE,SIGDN,PWSTR*);

/* Updated Windows 7 has a new IShellDispatch6 in its typelib */
DEFINE_GUID(IID_IWin7ShellDispatch6, 0x34936ba1, 0x67ad, 0x4c41, 0x99,0xb8, 0x8c,0x12,0xdf,0xf1,0xe9,0x74);

static void variant_set_string(VARIANT *v, const char *s)
{
    WCHAR wstr[MAX_PATH];
    MultiByteToWideChar(CP_ACP, 0, s, -1, wstr, MAX_PATH);
    V_VT(v) = VT_BSTR;
    V_BSTR(v) = SysAllocString(wstr);
}

static void init_function_pointers(void)
{
    HMODULE hshell32;

    hshell32 = GetModuleHandleA("shell32.dll");
    pSHGetNameFromIDList = (void*)GetProcAddress(hshell32, "SHGetNameFromIDList");
}

static void test_namespace(void)
{
    static const ShellSpecialFolderConstants special_folders[] =
    {
        ssfDESKTOP,
        ssfPROGRAMS,
        ssfCONTROLS,
        ssfPRINTERS,
        ssfPERSONAL,
        ssfFAVORITES,
        ssfSTARTUP,
        ssfRECENT,
        ssfSENDTO,
        ssfBITBUCKET,
        ssfSTARTMENU,
        ssfDESKTOPDIRECTORY,
        ssfDRIVES,
        ssfNETWORK,
        ssfNETHOOD,
        ssfFONTS,
        ssfTEMPLATES,
        ssfCOMMONSTARTMENU,
        ssfCOMMONPROGRAMS,
        ssfCOMMONSTARTUP,
        ssfCOMMONDESKTOPDIR,
        ssfAPPDATA,
        ssfPRINTHOOD,
        ssfLOCALAPPDATA,
        ssfALTSTARTUP,
        ssfCOMMONALTSTARTUP,
        ssfCOMMONFAVORITES,
        ssfINTERNETCACHE,
        ssfCOOKIES,
        ssfHISTORY,
        ssfCOMMONAPPDATA,
        ssfWINDOWS,
        ssfSYSTEM,
        ssfPROGRAMFILES,
        ssfMYPICTURES,
        ssfPROFILE,
        ssfSYSTEMx86,
        ssfPROGRAMFILESx86,
    };

    static const WCHAR backslashW[] = {'\\',0};
    static const WCHAR clsidW[] = {
        ':',':','{','6','4','5','F','F','0','4','0','-','5','0','8','1','-',
                    '1','0','1','B','-','9','F','0','8','-',
                    '0','0','A','A','0','0','2','F','9','5','4','E','}',0};

    static WCHAR tempW[MAX_PATH], curW[MAX_PATH];
    WCHAR *long_pathW = NULL;
    HRESULT r;
    IShellDispatch *sd;
    Folder *folder;
    Folder2 *folder2;
    FolderItem *item;
    VARIANT var;
    BSTR title, item_path;
    IDispatch *disp;
    int len, i;

    r = CoCreateInstance(&CLSID_Shell, NULL, CLSCTX_INPROC_SERVER, &IID_IShellDispatch, (void **)&sd);
    ok(SUCCEEDED(r), "Failed to create ShellDispatch object: %#x.\n", r);

    disp = NULL;
    r = IShellDispatch_get_Application(sd, &disp);
    ok(r == S_OK, "Failed to get application pointer, hr %#x.\n", r);
    ok(disp == (IDispatch *)sd, "Unexpected application pointer %p.\n", disp);
    IDispatch_Release(disp);

    disp = NULL;
    r = IShellDispatch_get_Parent(sd, &disp);
    ok(r == S_OK, "Failed to get Shell object parent, hr %#x.\n", r);
    ok(disp == (IDispatch *)sd, "Unexpected parent pointer %p.\n", disp);
    IDispatch_Release(disp);

    VariantInit(&var);
    folder = (void*)0xdeadbeef;
    r = IShellDispatch_NameSpace(sd, var, &folder);
    ok(r == S_FALSE, "expected S_FALSE, got %08x\n", r);
    ok(folder == NULL, "expected NULL, got %p\n", folder);

    /* test valid folder ids */
    for (i = 0; i < sizeof(special_folders)/sizeof(special_folders[0]); i++)
    {
        V_VT(&var) = VT_I4;
        V_I4(&var) = special_folders[i];
        folder = (void*)0xdeadbeef;
        r = IShellDispatch_NameSpace(sd, var, &folder);
        if (special_folders[i] == ssfALTSTARTUP || special_folders[i] == ssfCOMMONALTSTARTUP)
        todo_wine
            ok(r == S_OK || broken(r == S_FALSE) /* winxp */, "Failed to get folder for index %#x, got %08x\n", special_folders[i], r);
        else
            ok(r == S_OK, "Failed to get folder for index %#x, got %08x\n", special_folders[i], r);
        if (folder)
            Folder_Release(folder);
    }

    V_VT(&var) = VT_I4;
    V_I4(&var) = -1;
    folder = (void *)0xdeadbeef;
    r = IShellDispatch_NameSpace(sd, var, &folder);
    ok(r == S_FALSE, "Unexpected hr %#x.\n", r);
    ok(folder == NULL, "Unexpected folder instance %p\n", folder);

    V_VT(&var) = VT_I4;
    V_I4(&var) = ssfPROGRAMFILES;
    r = IShellDispatch_NameSpace(sd, var, &folder);
    ok(r == S_OK, "IShellDispatch::NameSpace failed: %08x\n", r);
    if (r == S_OK)
    {
        static WCHAR path[MAX_PATH];

        r = SHGetFolderPathW(NULL, CSIDL_PROGRAM_FILES, NULL, SHGFP_TYPE_CURRENT, path);
        ok(r == S_OK, "Failed to get folder path: %#x.\n", r);

        r = Folder_get_Title(folder, &title);
        ok(r == S_OK, "Folder::get_Title failed: %08x\n", r);
        if (r == S_OK)
        {
            /* On Win2000-2003 title is equal to program files directory name in
               HKLM\Software\Microsoft\Windows\CurrentVersion\ProgramFilesDir.
               On newer Windows it seems constant and is not changed
               if the program files directory name is changed */
            if (pSHGetNameFromIDList)
            {
                LPITEMIDLIST pidl;
                PWSTR name;

                r = SHGetSpecialFolderLocation(NULL, CSIDL_PROGRAM_FILES, &pidl);
                ok(r == S_OK, "SHGetSpecialFolderLocation failed: %08x\n", r);
                r = pSHGetNameFromIDList(pidl, SIGDN_NORMALDISPLAY, &name);
                ok(r == S_OK, "SHGetNameFromIDList failed: %08x\n", r);
                ok(!lstrcmpW(title, name), "expected %s, got %s\n", wine_dbgstr_w(name), wine_dbgstr_w(title));
                CoTaskMemFree(name);
                CoTaskMemFree(pidl);
            }
            else
            {
                WCHAR *p;

                p = path + lstrlenW(path);
                while (path < p && *(p - 1) != '\\')
                    p--;
                ok(!lstrcmpiW(title, p), "expected %s, got %s\n",
                 wine_dbgstr_w(p), wine_dbgstr_w(title));
            }
            SysFreeString(title);
        }
        r = Folder_QueryInterface(folder, &IID_Folder2, (LPVOID*)&folder2);
        ok(r == S_OK, "Folder::QueryInterface failed: %08x\n", r);
        if (r == S_OK)
        {
            r = Folder2_get_Self(folder2, &item);
            ok(r == S_OK, "Folder::get_Self failed: %08x\n", r);
            if (r == S_OK)
            {
                r = FolderItem_get_Path(item, &item_path);
                ok(r == S_OK, "FolderItem::get_Path failed: %08x\n", r);
                ok(!lstrcmpiW(item_path, path), "expected %s, got %s\n", wine_dbgstr_w(path), wine_dbgstr_w(item_path));
                SysFreeString(item_path);
                FolderItem_Release(item);
            }
            Folder2_Release(folder2);
        }
        Folder_Release(folder);
    }

    V_VT(&var) = VT_I4;
    V_I4(&var) = ssfBITBUCKET;
    r = IShellDispatch_NameSpace(sd, var, &folder);
    ok(r == S_OK, "IShellDispatch::NameSpace failed: %08x\n", r);

    r = Folder_QueryInterface(folder, &IID_Folder2, (void **)&folder2);
    ok(r == S_OK, "Failed to get Folder2 interface: %#x.\n", r);
    r = Folder2_get_Self(folder2, &item);
    ok(r == S_OK, "Folder::get_Self failed: %08x\n", r);
    r = FolderItem_get_Path(item, &item_path);
todo_wine {
    ok(r == S_OK, "FolderItem::get_Path failed: %08x\n", r);
    ok(!lstrcmpW(item_path, clsidW), "expected %s, got %s\n", wine_dbgstr_w(clsidW), wine_dbgstr_w(item_path));
}
    SysFreeString(item_path);
    FolderItem_Release(item);
    Folder2_Release(folder2);
    Folder_Release(folder);

    GetTempPathW(MAX_PATH, tempW);
    GetCurrentDirectoryW(MAX_PATH, curW);
    SetCurrentDirectoryW(tempW);
    CreateDirectoryW(winetestW, NULL);
    V_VT(&var) = VT_BSTR;
    V_BSTR(&var) = SysAllocString(winetestW);
    r = IShellDispatch_NameSpace(sd, var, &folder);
    ok(r == S_FALSE, "expected S_FALSE, got %08x\n", r);
    SysFreeString(V_BSTR(&var));

    GetFullPathNameW(winetestW, MAX_PATH, tempW, NULL);

    len = GetLongPathNameW(tempW, NULL, 0);
    long_pathW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    GetLongPathNameW(tempW, long_pathW, len);

    V_VT(&var) = VT_BSTR;
    V_BSTR(&var) = SysAllocString(tempW);
    r = IShellDispatch_NameSpace(sd, var, &folder);
    ok(r == S_OK, "IShellDispatch::NameSpace failed: %08x\n", r);

    disp = (void *)0xdeadbeef;
    r = Folder_get_Parent(folder, &disp);
    ok(r == E_NOTIMPL, "Unexpected hr %#x.\n", r);
    ok(disp == NULL, "Unexpected parent pointer %p.\n", disp);

    r = Folder_get_Title(folder, &title);
    ok(r == S_OK, "Failed to get folder title: %#x.\n", r);
    ok(!lstrcmpW(title, winetestW), "Unexpected title: %s\n",  wine_dbgstr_w(title));
    SysFreeString(title);

    r = Folder_QueryInterface(folder, &IID_Folder2, (void **)&folder2);
    ok(r == S_OK, "Failed to get Folder2 interface: %#x.\n", r);
    r = Folder2_get_Self(folder2, &item);
    ok(r == S_OK, "Folder::get_Self failed: %08x\n", r);
    r = FolderItem_get_Path(item, &item_path);
    ok(r == S_OK, "Failed to get item path: %#x.\n", r);
    ok(!lstrcmpW(item_path, long_pathW), "Unexpected path %s, got %s\n", wine_dbgstr_w(item_path), wine_dbgstr_w(long_pathW));
    SysFreeString(item_path);
    FolderItem_Release(item);
    Folder2_Release(folder2);

    Folder_Release(folder);
    VariantClear(&var);

    len = lstrlenW(tempW);
    if (len < MAX_PATH - 1)
    {
        lstrcatW(tempW, backslashW);
        V_VT(&var) = VT_BSTR;
        V_BSTR(&var) = SysAllocString(tempW);
        r = IShellDispatch_NameSpace(sd, var, &folder);
        ok(r == S_OK, "IShellDispatch::NameSpace failed: %08x\n", r);
        if (r == S_OK)
        {
            r = Folder_get_Title(folder, &title);
            ok(r == S_OK, "Folder::get_Title failed: %08x\n", r);
            if (r == S_OK)
            {
                ok(!lstrcmpW(title, winetestW), "bad title: %s\n",
                 wine_dbgstr_w(title));
                SysFreeString(title);
            }
            r = Folder_QueryInterface(folder, &IID_Folder2, (LPVOID*)&folder2);
            ok(r == S_OK, "Failed to get Folder2 interface: %#x.\n", r);
            if (r == S_OK)
            {
                r = Folder2_get_Self(folder2, &item);
                ok(r == S_OK, "Folder::get_Self failed: %08x\n", r);
                if (r == S_OK)
                {
                    r = FolderItem_get_Path(item, &item_path);
                    ok(r == S_OK, "FolderItem::get_Path failed: %08x\n", r);
                    ok(!lstrcmpW(item_path, long_pathW), "Unexpected path %s, got %s\n", wine_dbgstr_w(item_path),
                        wine_dbgstr_w(long_pathW));
                    SysFreeString(item_path);
                    FolderItem_Release(item);
                }
                Folder2_Release(folder2);
            }
            Folder_Release(folder);
        }
        SysFreeString(V_BSTR(&var));
    }

    HeapFree(GetProcessHeap(), 0, long_pathW);
    RemoveDirectoryW(winetestW);
    SetCurrentDirectoryW(curW);
    IShellDispatch_Release(sd);
}

static void test_items(void)
{
    static const struct
    {
        char name[32];
        enum
        {
            DIRECTORY,
            EMPTY_FILE,
        }
        type;
    }
    file_defs[] =
    {
        { "00-Myfolder",        DIRECTORY  },
        { "01-empty.bin",       EMPTY_FILE },
    };
    WCHAR path[MAX_PATH], cur_dir[MAX_PATH], orig_dir[MAX_PATH];
    HRESULT r;
    IShellDispatch *sd = NULL;
    Folder *folder = NULL;
    FolderItems *items;
    FolderItems2 *items2 = NULL;
    FolderItems3 *items3 = NULL;
    FolderItem *item = (FolderItem*)0xdeadbeef, *item2;
    FolderItemVerbs *verbs = (FolderItemVerbs*)0xdeadbeef;
    VARIANT var, int_index, str_index, str_index2;
    IDispatch *disp, *disp2;
    LONG count = -1;
    IUnknown *unk;
    HANDLE file;
    BSTR bstr;
    char cstr[64];
    int i;

    r = CoCreateInstance(&CLSID_Shell, NULL, CLSCTX_INPROC_SERVER, &IID_IShellDispatch, (void**)&sd);
    ok(SUCCEEDED(r), "CoCreateInstance failed: %08x\n", r);
    ok(!!sd, "sd is null\n");

    /* create and enter a temporary directory and a folder object for it */
    GetTempPathW(MAX_PATH, path);
    GetCurrentDirectoryW(MAX_PATH, orig_dir);
    SetCurrentDirectoryW(path);
    ok(CreateDirectoryW(winetestW, NULL), "CreateDirectory failed: %08x\n", GetLastError());
    GetFullPathNameW(winetestW, MAX_PATH, path, NULL);
    V_VT(&var) = VT_BSTR;
    V_BSTR(&var) = SysAllocString(path);

    EXPECT_REF(sd, 1);
    r = IShellDispatch_NameSpace(sd, var, &folder);
    ok(r == S_OK, "IShellDispatch::NameSpace failed: %08x\n", r);
    ok(!!folder, "folder is null\n");
    EXPECT_REF(folder, 1);
    EXPECT_REF(sd, 1);

    VariantClear(&var);
    SetCurrentDirectoryW(winetestW);
    GetCurrentDirectoryW(MAX_PATH, path);
    GetLongPathNameW(path, cur_dir, MAX_PATH);

    /* FolderItems grabs its Folder reference */
    items = NULL;
    r = Folder_Items(folder, &items);
    ok(r == S_OK, "Folder::Items failed: %08x\n", r);
    ok(!!items, "items is null\n");
    EXPECT_REF(folder, 2);
    EXPECT_REF(items, 1);

    unk = NULL;
    r = Folder_Items(folder, (FolderItems **)&unk);
    ok(r == S_OK, "Folder::Items failed: %08x\n", r);
    EXPECT_REF(folder, 3);
    IUnknown_Release(unk);
    EXPECT_REF(folder, 2);

    FolderItems_AddRef(items);
    EXPECT_REF(folder, 2);
    FolderItems_Release(items);

    /* Application property */
    disp = NULL;
    EXPECT_REF(sd, 1);
    r = Folder_get_Application(folder, &disp);
    ok(r == S_OK, "Failed to get application %#x.\n", r);
    ok(disp != (IDispatch *)sd, "Unexpected application pointer\n");
    EXPECT_REF(sd, 1);

    disp2 = NULL;
    r = Folder_get_Application(folder, &disp2);
    ok(r == S_OK, "Failed to get application %#x.\n", r);
    ok(disp2 == disp, "Unexpected application pointer\n");
    IDispatch_Release(disp2);

    r = IDispatch_QueryInterface(disp, &IID_IShellDispatch, (void **)&disp2);
    ok(r == S_OK, "Wrong instance, hr %#x.\n", r);
    IDispatch_Release(disp2);
    IDispatch_Release(disp);

    if (0) /* crashes on all versions of Windows */
        r = FolderItems_get_Count(items, NULL);

    r = FolderItems_get_Count(items, &count);
    ok(r == S_OK, "FolderItems::get_Count failed: %08x\n", r);
    ok(!count, "expected 0 files, got %d\n", count);

    V_VT(&var) = VT_I4;
    V_I4(&var) = 0;

    if (0) /* crashes on all versions of Windows */
        r = FolderItems_Item(items, var, NULL);

    r = FolderItems_Item(items, var, &item);
    ok(r == S_FALSE, "expected S_FALSE, got %08x\n", r);
    ok(!item, "item is not null\n");

    /* create test files */
    for (i = 0; i < sizeof(file_defs)/sizeof(file_defs[0]); i++)
    {
        switch (file_defs[i].type)
        {
            case DIRECTORY:
                r = CreateDirectoryA(file_defs[i].name, NULL);
                ok(r, "CreateDirectory failed: %08x\n", GetLastError());
                PathCombineA(cstr, file_defs[i].name, "foo.txt");
                file = CreateFileA(cstr, 0, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
                ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %08x\n", GetLastError());
                CloseHandle(file);
                break;

            case EMPTY_FILE:
                file = CreateFileA(file_defs[i].name, 0, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
                ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %08x\n", GetLastError());
                CloseHandle(file);
                break;
        }
    }

    /* test that get_Count is not aware of the newly created files */
    count = -1;
    r = FolderItems_get_Count(items, &count);
    ok(r == S_OK, "FolderItems::get_Count failed: %08x\n", r);
    ok(!count, "expected 0 files, got %d\n", count);

    /* test that the newly created files CAN be retrieved by string index */
    variant_set_string(&var, file_defs[0].name);
    item = NULL;
    r = FolderItems_Item(items, var, &item);
    ok(r == S_OK, "FolderItems::Item failed: %08x\n", r);
    ok(!!item, "item is null\n");

    disp = (void *)0xdeadbeef;
    r = FolderItems_get_Parent(items, &disp);
    ok(r == E_NOTIMPL, "Unexpected hr %#x.\n", r);
    ok(disp == NULL, "Unexpected parent pointer %p.\n", disp);

    r = FolderItem_get_Parent(item, &disp);
    ok(r == S_OK, "Failed to get parent pointer, hr %#x.\n", r);
    ok(disp == (IDispatch *)folder, "Unexpected parent pointer %p.\n", disp);
    IDispatch_Release(disp);

    if (item) FolderItem_Release(item);
    VariantClear(&var);

    /* recreate the items object */
    FolderItems_Release(items);
    items = NULL;
    r = Folder_Items(folder, &items);
    ok(r == S_OK, "Folder::Items failed: %08x\n", r);
    ok(!!items, "items is null\n");
    r = FolderItems_QueryInterface(items, &IID_FolderItems2, (void**)&items2);
    ok(r == S_OK || broken(r == E_NOINTERFACE) /* xp and later */, "FolderItems::QueryInterface failed: %08x\n", r);
    if (r == S_OK)
    {
        ok(!!items2, "items2 is null\n");
        FolderItems2_Release(items2);
    }
    r = FolderItems_QueryInterface(items, &IID_FolderItems3, (void**)&items3);
    ok(r == S_OK, "FolderItems::QueryInterface failed: %08x\n", r);
    ok(!!items3, "items3 is null\n");

    count = -1;
    r = FolderItems_get_Count(items, &count);
    ok(r == S_OK, "FolderItems::get_Count failed: %08x\n", r);
    ok(count == sizeof(file_defs)/sizeof(file_defs[0]),
       "expected %d files, got %d\n", (LONG)(sizeof(file_defs)/sizeof(file_defs[0])), count);

    V_VT(&var) = VT_EMPTY;
    item = (FolderItem*)0xdeadbeef;
    r = FolderItems_Item(items, var, &item);
    ok(r == E_NOTIMPL, "expected E_NOTIMPL, got %08x\n", r);
    ok(!item, "item is not null\n");

    V_VT(&var) = VT_I2;
    V_I2(&var) = 0;

    EXPECT_REF(folder, 2);
    EXPECT_REF(items, 2);
    item = NULL;
    r = FolderItems_Item(items, var, &item);
    ok(r == S_OK, "FolderItems::Item failed: %08x\n", r);
    ok(!!item, "item is null\n");
    EXPECT_REF(folder, 3);
    EXPECT_REF(items, 2);

    r = Folder_get_Application(folder, &disp);
    ok(r == S_OK, "Failed to get application pointer %#x.\n", r);
    r = FolderItem_get_Application(item, &disp2);
    ok(r == S_OK, "Failed to get application pointer %#x.\n", r);
    ok(disp == disp2, "Unexpected application pointer.\n");
    IDispatch_Release(disp2);
    IDispatch_Release(disp);

    FolderItem_Release(item);

    V_VT(&var) = VT_I4;
    V_I4(&var) = 0;
    item = NULL;
    r = FolderItems_Item(items, var, &item);
    ok(r == S_OK, "FolderItems::Item failed: %08x\n", r);
    ok(!!item, "item is null\n");
    if (item) FolderItem_Release(item);

    V_I4(&var) = -1;
    item = (FolderItem*)0xdeadbeef;
    r = FolderItems_Item(items, var, &item);
    ok(r == S_FALSE, "expected S_FALSE, got %08x\n", r);
    ok(!item, "item is not null\n");

    V_VT(&var) = VT_ERROR;
    V_ERROR(&var) = 0;
    item = NULL;
    r = FolderItems_Item(items, var, &item);
    ok(r == S_OK, "expected S_OK, got %08x\n", r);
    ok(!!item, "item is null\n");
    if (item)
    {
        bstr = NULL;
        r = FolderItem_get_Path(item, &bstr);
        ok(r == S_OK, "FolderItem::get_Path failed: %08x\n", r);
        ok(!lstrcmpW(bstr, cur_dir),
           "expected %s, got %s\n", wine_dbgstr_w(cur_dir), wine_dbgstr_w(bstr));
        SysFreeString(bstr);
        FolderItem_Release(item);
    }

    V_VT(&int_index) = VT_I4;

    /* test the folder item corresponding to each file */
    for (i = 0; i < sizeof(file_defs)/sizeof(file_defs[0]); i++)
    {
        V_I4(&int_index) = i;
        variant_set_string(&str_index, file_defs[i].name);

        item = NULL;
        r = FolderItems_Item(items, int_index, &item);
        ok(r == S_OK, "file_defs[%d]: FolderItems::Item failed: %08x\n", i, r);
        ok(!!item, "file_defs[%d]: item is null\n", i);

        item2 = NULL;
        r = FolderItems_Item(items, int_index, &item2);
        ok(r == S_OK, "file_defs[%d]: FolderItems::Item failed: %08x\n", i, r);
        ok(item2 != item, "file_defs[%d]: item and item2 are the same\n", i);
        FolderItem_Release(item2);

        bstr = NULL;
        r = FolderItem_get_Path(item, &bstr);
        ok(r == S_OK, "file_defs[%d]: FolderItem::get_Path failed: %08x\n", i, r);
        PathCombineW(path, cur_dir, V_BSTR(&str_index));
        ok(!lstrcmpW(bstr, path),
           "file_defs[%d]: expected %s, got %s\n", i, wine_dbgstr_w(path), wine_dbgstr_w(bstr));
        SysFreeString(bstr);

        item = NULL;
        r = FolderItems_Item(items, str_index, &item);
        ok(r == S_OK, "file_defs[%d]: FolderItems::Item failed: %08x\n", i, r);
        ok(!!item, "file_defs[%d]: item is null\n", i);

        bstr = NULL;
        r = FolderItem_get_Path(item, &bstr);
        ok(r == S_OK, "file_defs[%d]: FolderItem::get_Path failed: %08x\n", i, r);
        PathCombineW(path, cur_dir, V_BSTR(&str_index));
        ok(!lstrcmpW(bstr, path),
           "file_defs[%d]: expected %s, got %s\n", i, wine_dbgstr_w(path), wine_dbgstr_w(bstr));
        SysFreeString(bstr);

        FolderItem_Release(item);

        if (file_defs[i].type == DIRECTORY)
        {
            /* test that getting an item object for a file in a subdirectory succeeds */
            PathCombineA(cstr, file_defs[i].name, "foo.txt");
            variant_set_string(&str_index2, cstr);
            item2 = NULL;
            r = FolderItems_Item(items, str_index2, &item2);
            ok(r == S_OK, "file_defs[%d]: FolderItems::Item failed: %08x\n", i, r);
            ok(!!item2, "file_defs[%d]: item is null\n", i);
            if (item2) FolderItem_Release(item2);
            VariantClear(&str_index2);

            /* delete the file in the subdirectory */
            ok(DeleteFileA(cstr), "file_defs[%d]: DeleteFile failed: %08x\n", i, GetLastError());

            /* test that getting an item object via a relative path fails */
            strcpy(cstr, file_defs[i].name);
            strcat(cstr, "\\..\\");
            strcat(cstr, file_defs[i].name);
            variant_set_string(&str_index2, cstr);
            item2 = (FolderItem*)0xdeadbeef;
            r = FolderItems_Item(items, str_index2, &item2);
       todo_wine {
            ok(r == S_FALSE, "file_defs[%d]: expected S_FALSE, got %08x\n", i, r);
            ok(!item2, "file_defs[%d]: item is not null\n", i);
       }
            if (item2) FolderItem_Release(item2);
            VariantClear(&str_index2);

            /* remove the directory */
            ok(RemoveDirectoryA(file_defs[i].name), "file_defs[%d]: RemoveDirectory failed: %08x\n", i, GetLastError());
        }
        else
        {
            ok(DeleteFileA(file_defs[i].name), "file_defs[%d]: DeleteFile failed: %08x\n", i, GetLastError());
        }

        /* test that the folder item is still accessible by integer index */
        item = NULL;
        r = FolderItems_Item(items, int_index, &item);
        ok(r == S_OK, "file_defs[%d]: FolderItems::Item failed: %08x\n", i, r);
        ok(!!item, "file_defs[%d]: item is null\n", i);

        bstr = NULL;
        r = FolderItem_get_Path(item, &bstr);
        ok(r == S_OK, "file_defs[%d]: FolderItem::get_Path failed: %08x\n", i, r);
        PathCombineW(path, cur_dir, V_BSTR(&str_index));
        ok(!lstrcmpW(bstr, path),
           "file_defs[%d]: expected %s, got %s\n", i, wine_dbgstr_w(path), wine_dbgstr_w(bstr));
        SysFreeString(bstr);

        FolderItem_Release(item);

        /* test that the folder item is no longer accessible by string index */
        item = (FolderItem*)0xdeadbeef;
        r = FolderItems_Item(items, str_index, &item);
        ok(r == S_FALSE, "file_defs[%d]: expected S_FALSE, got %08x\n", i, r);
        ok(!item, "file_defs[%d]: item is not null\n", i);

        VariantClear(&str_index);
    }

    /* test that there are only as many folder items as there were files */
    V_I4(&int_index) = sizeof(file_defs)/sizeof(file_defs[0]);
    item = (FolderItem*)0xdeadbeef;
    r = FolderItems_Item(items, int_index, &item);
    ok(r == S_FALSE, "expected S_FALSE, got %08x\n", r);
    ok(!item, "item is not null\n");

    if (0) /* crashes on xp */
    {
        r = FolderItems_get_Application(items, NULL);
        ok(r == E_INVALIDARG, "expected E_INVALIDARG, got %08x\n", r);
    }

    r = FolderItems_get_Application(items, &disp);
    ok(r == S_OK, "FolderItems::get_Application failed: %08x\n", r);

    r = Folder_get_Application(folder, &disp2);
    ok(r == S_OK, "Failed to get application pointer, hr %#x.\n", r);
    ok(disp == disp2, "Unexpected application pointer.\n");
    IDispatch_Release(disp2);
    IDispatch_Release(disp);

    if (0) /* crashes on xp */
    {
        r = FolderItems_get_Parent(items, NULL);
        ok(r == E_NOTIMPL, "expected E_NOTIMPL, got %08x\n", r);
    }

    disp = (IDispatch*)0xdeadbeef;
    r = FolderItems_get_Parent(items, &disp);
    ok(r == E_NOTIMPL, "expected E_NOTIMPL, got %08x\n", r);
    ok(!disp, "disp is not null\n");

    if (0) /* crashes on xp */
    {
        r = FolderItems__NewEnum(items, NULL);
        ok(r == E_INVALIDARG, "expected E_INVALIDARG, got %08x\n", r);
    }

    r = FolderItems__NewEnum(items, &unk);
todo_wine
    ok(r == S_OK, "FolderItems::_NewEnum failed: %08x\n", r);
todo_wine
    ok(!!unk, "unk is null\n");
    if (unk) IUnknown_Release(unk);

    if (items3)
    {
        r = FolderItems3_Filter(items3, 0, NULL);
todo_wine
        ok(r == S_OK, "expected S_OK, got %08x\n", r);

        if (0) /* crashes on xp */
        {
            r = FolderItems3_get_Verbs(items3, NULL);
            ok(r == E_INVALIDARG, "expected E_INVALIDARG, got %08x\n", r);
        }

        r = FolderItems3_get_Verbs(items3, &verbs);
todo_wine
        ok(r == S_FALSE, "expected S_FALSE, got %08x\n", r);
        ok(!verbs, "verbs is not null\n");
    }

    /* remove the temporary directory and restore the original working directory */
    GetTempPathW(MAX_PATH, path);
    SetCurrentDirectoryW(path);
    ok(RemoveDirectoryW(winetestW), "RemoveDirectory failed: %08x\n", GetLastError());
    SetCurrentDirectoryW(orig_dir);

    /* test that everything stops working after the directory has been removed */
    count = -1;
    r = FolderItems_get_Count(items, &count);
    ok(r == S_OK, "FolderItems::get_Count failed: %08x\n", r);
    ok(!count, "expected 0 files, got %d\n", count);

    item = NULL;
    V_I4(&int_index) = 0;
    item = (FolderItem*)0xdeadbeef;
    r = FolderItems_Item(items, int_index, &item);
    ok(r == S_FALSE, "expected S_FALSE, got %08x\n", r);
    ok(!item, "item is not null\n");

    variant_set_string(&str_index, file_defs[0].name);
    item = (FolderItem*)0xdeadbeef;
    r = FolderItems_Item(items, str_index, &item);
    ok(r == S_FALSE, "expected S_FALSE, got %08x\n", r);
    ok(!item, "item is not null\n");
    VariantClear(&str_index);

    FolderItems_Release(items);
    Folder_Release(folder);
    if (items3) FolderItems3_Release(items3);
    IShellDispatch_Release(sd);
}

static void test_service(void)
{
    static const WCHAR spooler[] = {'S','p','o','o','l','e','r',0};
    static const WCHAR dummyW[] = {'d','u','m','m','y',0};
    SERVICE_STATUS_PROCESS status;
    SC_HANDLE scm, service;
    IShellDispatch2 *sd;
    DWORD dummy;
    HRESULT hr;
    BSTR name;
    VARIANT v;

    hr = CoCreateInstance(&CLSID_Shell, NULL, CLSCTX_INPROC_SERVER,
        &IID_IShellDispatch2, (void**)&sd);
    if (hr != S_OK)
    {
        win_skip("IShellDispatch2 not supported\n");
        return;
    }

    V_VT(&v) = VT_I2;
    V_I2(&v) = 10;
    hr = IShellDispatch2_IsServiceRunning(sd, NULL, &v);
    ok(V_VT(&v) == VT_BOOL, "got %d\n", V_VT(&v));
    ok(V_BOOL(&v) == VARIANT_FALSE, "got %d\n", V_BOOL(&v));
    EXPECT_HR(hr, S_OK);

    scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
    service = OpenServiceW(scm, spooler, SERVICE_QUERY_STATUS);
    QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (BYTE *)&status, sizeof(SERVICE_STATUS_PROCESS), &dummy);
    CloseServiceHandle(service);
    CloseServiceHandle(scm);

    /* service should exist */
    name = SysAllocString(spooler);
    V_VT(&v) = VT_I2;
    hr = IShellDispatch2_IsServiceRunning(sd, name, &v);
    EXPECT_HR(hr, S_OK);
    ok(V_VT(&v) == VT_BOOL, "got %d\n", V_VT(&v));
    if (status.dwCurrentState == SERVICE_RUNNING)
        ok(V_BOOL(&v) == VARIANT_TRUE, "got %d\n", V_BOOL(&v));
    else
        ok(V_BOOL(&v) == VARIANT_FALSE, "got %d\n", V_BOOL(&v));
    SysFreeString(name);

    /* service doesn't exist */
    name = SysAllocString(dummyW);
    V_VT(&v) = VT_I2;
    hr = IShellDispatch2_IsServiceRunning(sd, name, &v);
    EXPECT_HR(hr, S_OK);
    ok(V_VT(&v) == VT_BOOL, "got %d\n", V_VT(&v));
    ok(V_BOOL(&v) == VARIANT_FALSE, "got %d\n", V_BOOL(&v));
    SysFreeString(name);

    IShellDispatch2_Release(sd);
}

static void test_dispatch_typeinfo(IDispatch *disp, REFIID *riid)
{
    ITypeInfo *typeinfo;
    TYPEATTR *typeattr;
    UINT count;
    HRESULT hr;

    count = 10;
    hr = IDispatch_GetTypeInfoCount(disp, &count);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(count == 1, "got %u\n", count);

    hr = IDispatch_GetTypeInfo(disp, 0, LOCALE_SYSTEM_DEFAULT, &typeinfo);
    ok(hr == S_OK, "got 0x%08x\n", hr);

    hr = ITypeInfo_GetTypeAttr(typeinfo, &typeattr);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    while (!IsEqualGUID(*riid, &IID_NULL)) {
        if (IsEqualGUID(&typeattr->guid, *riid))
            break;
        riid++;
    }
    ok(IsEqualGUID(&typeattr->guid, *riid), "unexpected type guid %s\n", wine_dbgstr_guid(&typeattr->guid));

    ITypeInfo_ReleaseTypeAttr(typeinfo, typeattr);
    ITypeInfo_Release(typeinfo);
}

static void test_ShellFolderViewDual(void)
{
    static const IID *shelldisp_riids[] = {
        &IID_IShellDispatch6,
        &IID_IShellDispatch5,
        &IID_IShellDispatch4,
        &IID_IShellDispatch2,
        &IID_IWin7ShellDispatch6,
        &IID_NULL
    };
    IShellFolderViewDual *viewdual;
    IShellFolder *desktop, *tmpdir;
    IShellView *view, *view2;
    IDispatch *disp, *disp2;
    WCHAR pathW[MAX_PATH];
    LPITEMIDLIST pidl;
    HRESULT hr;

    /* IShellFolderViewDual is not an IShellView extension */
    hr = SHGetDesktopFolder(&desktop);
    ok(hr == S_OK, "got 0x%08x\n", hr);

    hr = IShellFolder_CreateViewObject(desktop, NULL, &IID_IShellView, (void**)&view);
    ok(hr == S_OK, "got 0x%08x\n", hr);

    hr = IShellView_QueryInterface(view, &IID_IShellFolderViewDual, (void**)&viewdual);
    ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);

    hr = IShellView_GetItemObject(view, SVGIO_BACKGROUND, &IID_IDispatch, (void**)&disp);
    ok(hr == S_OK, "got 0x%08x\n", hr);

    hr = IShellView_GetItemObject(view, SVGIO_BACKGROUND, &IID_IDispatch, (void**)&disp2);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(disp2 == disp, "got %p, %p\n", disp2, disp);
    IDispatch_Release(disp2);

    hr = IDispatch_QueryInterface(disp, &IID_IShellFolderViewDual, (void**)&viewdual);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(disp == (IDispatch*)viewdual, "got %p, expected %p\n", viewdual, disp);

    hr = IShellFolderViewDual_QueryInterface(viewdual, &IID_IShellView, (void**)&view2);
    ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);

    /* get_Application() */

if (0) /* crashes on pre-vista */ {
    hr = IShellFolderViewDual_get_Application(viewdual, NULL);
    ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
}
    hr = IShellFolderViewDual_get_Application(viewdual, &disp2);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(disp2 != (IDispatch*)viewdual, "got %p, %p\n", disp2, viewdual);
    test_dispatch_typeinfo(disp2, shelldisp_riids);
    IDispatch_Release(disp2);

    IShellFolderViewDual_Release(viewdual);
    IDispatch_Release(disp);

    disp = (void*)0xdeadbeef;
    hr = IShellView_GetItemObject(view, SVGIO_BACKGROUND, &IID_IShellFolderViewDual, (void**)&disp);
    ok(hr == E_NOINTERFACE || broken(hr == E_NOTIMPL) /* win2k */, "got 0x%08x\n", hr);
    ok(disp == NULL, "got %p\n", disp);
    IShellView_Release(view);

    /* Try with some other folder, that's not a desktop */
    GetTempPathW(sizeof(pathW)/sizeof(pathW[0]), pathW);
    hr = IShellFolder_ParseDisplayName(desktop, NULL, NULL, pathW, NULL, &pidl, NULL);
    ok(hr == S_OK, "got 0x%08x\n", hr);

    hr = IShellFolder_BindToObject(desktop, pidl, NULL, &IID_IShellFolder, (void**)&tmpdir);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    CoTaskMemFree(pidl);

    hr = IShellFolder_CreateViewObject(desktop, NULL, &IID_IShellView, (void**)&view);
    ok(hr == S_OK, "got 0x%08x\n", hr);

    hr = IShellView_QueryInterface(view, &IID_IShellFolderViewDual, (void**)&viewdual);
    ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);

    hr = IShellView_GetItemObject(view, SVGIO_BACKGROUND, &IID_IDispatch, (void**)&disp);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    IDispatch_Release(disp);
    IShellView_Release(view);

    IShellFolder_Release(tmpdir);
    IShellFolder_Release(desktop);
}

static void test_ShellWindows(void)
{
    IShellWindows *shellwindows;
    LONG cookie, cookie2, ret;
    IDispatch *disp;
    VARIANT v, v2;
    HRESULT hr;
    HWND hwnd;

    hr = CoCreateInstance(&CLSID_ShellWindows, NULL, CLSCTX_LOCAL_SERVER,
        &IID_IShellWindows, (void**)&shellwindows);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    /* TODO: remove when explorer startup with clean prefix is fixed */
    if (hr != S_OK)
        return;

if (0) /* NULL out argument - currently crashes on Wine */ {
    hr = IShellWindows_Register(shellwindows, NULL, 0, SWC_EXPLORER, NULL);
    ok(hr == HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER), "got 0x%08x\n", hr);
}
    hr = IShellWindows_Register(shellwindows, NULL, 0, SWC_EXPLORER, &cookie);
todo_wine
    ok(hr == E_POINTER, "got 0x%08x\n", hr);

    hr = IShellWindows_Register(shellwindows, (IDispatch*)shellwindows, 0, SWC_EXPLORER, &cookie);
todo_wine
    ok(hr == E_POINTER, "got 0x%08x\n", hr);

    hr = IShellWindows_Register(shellwindows, (IDispatch*)shellwindows, 0, SWC_EXPLORER, &cookie);
todo_wine
    ok(hr == E_POINTER, "got 0x%08x\n", hr);

    hwnd = CreateWindowExA(0, "button", "test", BS_CHECKBOX | WS_VISIBLE | WS_POPUP,
                           0, 0, 50, 14, 0, 0, 0, NULL);
    ok(hwnd != NULL, "got %p, error %d\n", hwnd, GetLastError());

    cookie = 0;
    hr = IShellWindows_Register(shellwindows, NULL, HandleToLong(hwnd), SWC_EXPLORER, &cookie);
todo_wine {
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(cookie != 0, "got %d\n", cookie);
}
    cookie2 = 0;
    hr = IShellWindows_Register(shellwindows, NULL, HandleToLong(hwnd), SWC_EXPLORER, &cookie2);
todo_wine {
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(cookie2 != 0 && cookie2 != cookie, "got %d\n", cookie2);
}
    hr = IShellWindows_Revoke(shellwindows, cookie);
todo_wine
    ok(hr == S_OK, "got 0x%08x\n", hr);
    hr = IShellWindows_Revoke(shellwindows, cookie2);
todo_wine
    ok(hr == S_OK, "got 0x%08x\n", hr);

    hr = IShellWindows_Revoke(shellwindows, 0);
todo_wine
    ok(hr == S_FALSE, "got 0x%08x\n", hr);

    /* we can register ourselves as desktop, but FindWindowSW still returns real desktop window */
    cookie = 0;
    hr = IShellWindows_Register(shellwindows, NULL, HandleToLong(hwnd), SWC_DESKTOP, &cookie);
todo_wine {
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(cookie != 0, "got %d\n", cookie);
}
    disp = (void*)0xdeadbeef;
    ret = 0xdead;
    VariantInit(&v);
    hr = IShellWindows_FindWindowSW(shellwindows, &v, &v, SWC_DESKTOP, &ret, SWFO_NEEDDISPATCH, &disp);
    ok(hr == S_OK || broken(hr == S_FALSE), "got 0x%08x\n", hr);
    if (hr == S_FALSE) /* winxp and earlier */ {
        win_skip("SWC_DESKTOP is not supported, some tests will be skipped.\n");
        /* older versions allowed to register SWC_DESKTOP and access it with FindWindowSW */
        ok(disp == NULL, "got %p\n", disp);
        ok(ret == 0, "got %d\n", ret);
    }
    else {
        static const IID *browser_riids[] = {
            &IID_IWebBrowser2,
            &IID_NULL
        };

        static const IID *viewdual_riids[] = {
            &IID_IShellFolderViewDual3,
            &IID_NULL
        };

        IShellFolderViewDual *view;
        IShellBrowser *sb, *sb2;
        IServiceProvider *sp;
        IDispatch *doc, *app;
        IWebBrowser2 *wb;
        IShellView *sv;
        IUnknown *unk;

        ok(disp != NULL, "got %p\n", disp);
        ok(ret != HandleToUlong(hwnd), "got %d\n", ret);

        /* IDispatch-related tests */
        test_dispatch_typeinfo(disp, browser_riids);

        /* IWebBrowser2 */
        hr = IDispatch_QueryInterface(disp, &IID_IWebBrowser2, (void**)&wb);
        ok(hr == S_OK, "got 0x%08x\n", hr);

        hr = IWebBrowser2_Refresh(wb);
todo_wine
        ok(hr == S_OK, "got 0x%08x\n", hr);

        hr = IWebBrowser2_get_Application(wb, &app);
        ok(hr == S_OK, "got 0x%08x\n", hr);
        ok(disp == app, "got %p, %p\n", app, disp);
        IDispatch_Release(app);

        hr = IWebBrowser2_get_Document(wb, &doc);
todo_wine
        ok(hr == S_OK, "got 0x%08x\n", hr);
if (hr == S_OK) {
        test_dispatch_typeinfo(doc, viewdual_riids);
}
        IWebBrowser2_Release(wb);

        /* IServiceProvider */
        hr = IDispatch_QueryInterface(disp, &IID_IShellFolderViewDual, (void**)&view);
        ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);

        hr = IDispatch_QueryInterface(disp, &IID_IServiceProvider, (void**)&sp);
        ok(hr == S_OK, "got 0x%08x\n", hr);

        hr = IServiceProvider_QueryService(sp, &SID_STopLevelBrowser, &IID_IShellBrowser, (void**)&sb);
        ok(hr == S_OK, "got 0x%08x\n", hr);

        hr = IServiceProvider_QueryService(sp, &SID_STopLevelBrowser, &IID_IShellBrowser, (void**)&sb2);
        ok(hr == S_OK, "got 0x%08x\n", hr);
        ok(sb == sb2, "got %p, %p\n", sb, sb2);

        hr = IServiceProvider_QueryService(sp, &SID_STopLevelBrowser, &IID_IOleWindow, (void**)&unk);
        ok(hr == S_OK, "got 0x%08x\n", hr);
        IUnknown_Release(unk);

        hr = IServiceProvider_QueryService(sp, &SID_STopLevelBrowser, &IID_IExplorerBrowser, (void**)&unk);
        ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);

        hr = IShellBrowser_QueryInterface(sb, &IID_IExplorerBrowser, (void**)&unk);
        ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);

        hr = IShellBrowser_QueryInterface(sb, &IID_IWebBrowser2, (void**)&unk);
        ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);

        hr = IShellBrowser_QueryInterface(sb, &IID_IDispatch, (void**)&unk);
        ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);

        hr = IShellBrowser_QueryActiveShellView(sb, &sv);
        ok(hr == S_OK, "got 0x%08x\n", hr);
        IShellView_Release(sv);

        IShellBrowser_Release(sb2);
        IShellBrowser_Release(sb);

        hr = IServiceProvider_QueryService(sp, &SID_STopLevelBrowser, &IID_IUnknown, (void**)&unk);
        ok(hr == S_OK, "got 0x%08x\n", hr);

        hr = IUnknown_QueryInterface(unk, &IID_IShellBrowser, (void**)&sb2);
        ok(hr == S_OK, "got 0x%08x\n", hr);
        IShellBrowser_Release(sb2);
        IUnknown_Release(unk);

        hr = IServiceProvider_QueryService(sp, &SID_STopLevelBrowser, &IID_IShellView, (void**)&sv);
        ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);

        IServiceProvider_Release(sp);
        IDispatch_Release(disp);
    }

    disp = (void*)0xdeadbeef;
    ret = 0xdead;
    VariantInit(&v);
    hr = IShellWindows_FindWindowSW(shellwindows, &v, &v, SWC_DESKTOP, &ret, 0, &disp);
    ok(hr == S_OK || broken(hr == S_FALSE) /* winxp */, "got 0x%08x\n", hr);
    ok(disp == NULL, "got %p\n", disp);
    ok(ret != HandleToUlong(hwnd), "got %d\n", ret);

    disp = (void*)0xdeadbeef;
    ret = 0xdead;
    V_VT(&v) = VT_I4;
    V_I4(&v) = cookie;
    VariantInit(&v2);
    hr = IShellWindows_FindWindowSW(shellwindows, &v, &v2, SWC_BROWSER, &ret, SWFO_COOKIEPASSED, &disp);
todo_wine
    ok(hr == S_FALSE, "got 0x%08x\n", hr);
    ok(disp == NULL, "got %p\n", disp);
    ok(ret == 0, "got %d\n", ret);

    hr = IShellWindows_Revoke(shellwindows, cookie);
todo_wine
    ok(hr == S_OK, "got 0x%08x\n", hr);
    DestroyWindow(hwnd);
    IShellWindows_Release(shellwindows);
}

static void test_ParseName(void)
{
    static const WCHAR cadabraW[] = {'c','a','d','a','b','r','a',0};
    WCHAR pathW[MAX_PATH];
    IShellDispatch *sd;
    FolderItem *item;
    Folder *folder;
    HRESULT hr;
    VARIANT v;
    BSTR str;

    hr = CoCreateInstance(&CLSID_Shell, NULL, CLSCTX_INPROC_SERVER,
        &IID_IShellDispatch, (void**)&sd);
    ok(hr == S_OK, "got 0x%08x\n", hr);

    GetTempPathW(sizeof(pathW)/sizeof(pathW[0]), pathW);
    V_VT(&v) = VT_BSTR;
    V_BSTR(&v) = SysAllocString(pathW);
    hr = IShellDispatch_NameSpace(sd, v, &folder);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    VariantClear(&v);

    item = (void*)0xdeadbeef;
    hr = Folder_ParseName(folder, NULL, &item);
    ok(hr == S_FALSE || broken(hr == E_INVALIDARG) /* win2k */, "got 0x%08x\n", hr);
    ok(item == NULL, "got %p\n", item);

    /* empty name */
    str = SysAllocStringLen(NULL, 0);
    item = (void*)0xdeadbeef;
    hr = Folder_ParseName(folder, str, &item);
    ok(hr == S_FALSE || broken(hr == E_INVALIDARG) /* win2k */, "got 0x%08x\n", hr);
    ok(item == NULL, "got %p\n", item);
    SysFreeString(str);

    /* path doesn't exist */
    str = SysAllocString(cadabraW);
    item = (void*)0xdeadbeef;
    hr = Folder_ParseName(folder, str, &item);
    ok(hr == S_FALSE || broken(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) /* win2k */,
        "got 0x%08x\n", hr);
    ok(item == NULL, "got %p\n", item);
    SysFreeString(str);

    lstrcatW(pathW, cadabraW);
    CreateDirectoryW(pathW, NULL);

    str = SysAllocString(cadabraW);
    item = NULL;
    hr = Folder_ParseName(folder, str, &item);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(item != NULL, "got %p\n", item);
    SysFreeString(str);

    hr = FolderItem_get_Path(item, &str);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(str[0] != 0, "path %s\n", wine_dbgstr_w(str));
    SysFreeString(str);

    RemoveDirectoryW(pathW);
    FolderItem_Release(item);
    Folder_Release(folder);
    IShellDispatch_Release(sd);
}

static void test_Verbs(void)
{
    FolderItemVerbs *verbs, *verbs2;
    WCHAR pathW[MAX_PATH];
    FolderItemVerb *verb;
    IShellDispatch *sd;
    FolderItem *item;
    Folder2 *folder2;
    IDispatch *disp;
    Folder *folder;
    HRESULT hr;
    LONG count, i;
    VARIANT v;
    BSTR str;

    hr = CoCreateInstance(&CLSID_Shell, NULL, CLSCTX_INPROC_SERVER,
        &IID_IShellDispatch, (void**)&sd);
    ok(hr == S_OK, "got 0x%08x\n", hr);

    GetTempPathW(sizeof(pathW)/sizeof(pathW[0]), pathW);
    V_VT(&v) = VT_BSTR;
    V_BSTR(&v) = SysAllocString(pathW);
    hr = IShellDispatch_NameSpace(sd, v, &folder);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    VariantClear(&v);

    hr = Folder_QueryInterface(folder, &IID_Folder2, (void**)&folder2);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    Folder_Release(folder);

    hr = Folder2_get_Self(folder2, &item);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    Folder2_Release(folder2);

if (0) { /* crashes on some systems */
    hr = FolderItem_Verbs(item, NULL);
    ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
}
    hr = FolderItem_Verbs(item, &verbs);
    ok(hr == S_OK, "got 0x%08x\n", hr);

    hr = FolderItem_Verbs(item, &verbs2);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(verbs2 != verbs, "Unexpected verbs pointer.\n");
    FolderItemVerbs_Release(verbs2);

    disp = (void *)0xdeadbeef;
    hr = FolderItemVerbs_get_Application(verbs, &disp);
    ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr);
    ok(disp == NULL, "Unexpected application pointer.\n");

    disp = (void *)0xdeadbeef;
    hr = FolderItemVerbs_get_Parent(verbs, &disp);
    ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr);
    ok(disp == NULL, "Unexpected parent pointer %p.\n", disp);

if (0) { /* crashes on winxp/win2k3 */
    hr = FolderItemVerbs_get_Count(verbs, NULL);
    ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
}
    count = 0;
    hr = FolderItemVerbs_get_Count(verbs, &count);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(count > 0, "got count %d\n", count);

if (0) { /* crashes on winxp/win2k3 */
    V_VT(&v) = VT_I4;
    V_I4(&v) = 0;
    hr = FolderItemVerbs_Item(verbs, v, NULL);
    ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
}
    /* there's always one item more, so you can access [0,count],
       instead of actual [0,count) */
    for (i = 0; i <= count; i++) {
        V_VT(&v) = VT_I4;
        V_I4(&v) = i;
        hr = FolderItemVerbs_Item(verbs, v, &verb);
        ok(hr == S_OK, "got 0x%08x\n", hr);
        hr = FolderItemVerb_get_Name(verb, &str);
        ok(hr == S_OK, "got 0x%08x\n", hr);
        ok(str != NULL, "%d: name %s\n", i, wine_dbgstr_w(str));
        if (i == count)
            ok(str[0] == 0, "%d: got terminating item %s\n", i, wine_dbgstr_w(str));

        disp = (void *)0xdeadbeef;
        hr = FolderItemVerb_get_Parent(verb, &disp);
        ok(hr == E_NOTIMPL, "got %#x.\n", hr);
        ok(disp == NULL, "Unexpected parent pointer %p.\n", disp);

        disp = (void *)0xdeadbeef;
        hr = FolderItemVerb_get_Application(verb, &disp);
        ok(hr == E_NOTIMPL, "got %#x.\n", hr);
        ok(disp == NULL, "Unexpected parent pointer %p.\n", disp);

        SysFreeString(str);
        FolderItemVerb_Release(verb);
    }

    V_VT(&v) = VT_I4;
    V_I4(&v) = count+1;
    verb = NULL;
    hr = FolderItemVerbs_Item(verbs, v, &verb);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(verb == NULL, "got %p\n", verb);

    FolderItemVerbs_Release(verbs);
    FolderItem_Release(item);
    IShellDispatch_Release(sd);
}

static void test_ShellExecute(void)
{
    HRESULT hr;
    IShellDispatch2 *sd;
    BSTR name;
    VARIANT args, dir, op, show;

    static const WCHAR regW[] = {'r','e','g',0};

    hr = CoCreateInstance(&CLSID_Shell, NULL, CLSCTX_INPROC_SERVER,
        &IID_IShellDispatch2, (void**)&sd);
    if (hr != S_OK)
    {
        win_skip("IShellDispatch2 not supported\n");
        return;
    }

    VariantInit(&args);
    VariantInit(&dir);
    VariantInit(&op);
    VariantInit(&show);

    V_VT(&show) = VT_I4;
    V_I4(&show) = 0;

    name = SysAllocString(regW);

    hr = IShellDispatch2_ShellExecute(sd, name, args, dir, op, show);
    ok(hr == S_OK, "ShellExecute failed: %08x\n", hr);

    /* test invalid value for show */
    V_VT(&show) = VT_BSTR;
    V_BSTR(&show) = name;

    hr = IShellDispatch2_ShellExecute(sd, name, args, dir, op, show);
    ok(hr == S_OK, "ShellExecute failed: %08x\n", hr);

    SysFreeString(name);
}

START_TEST(shelldispatch)
{
    HRESULT r;

    r = CoInitialize(NULL);
    ok(SUCCEEDED(r), "CoInitialize failed: %08x\n", r);
    if (FAILED(r))
        return;

    init_function_pointers();
    test_namespace();
    test_items();
    test_service();
    test_ShellFolderViewDual();
    test_ShellWindows();
    test_ParseName();
    test_Verbs();
    test_ShellExecute();

    CoUninitialize();
}