ordinal.c File Reference

#include <stdio.h>
#include "wine/test.h"
#include "winbase.h"
#include "winerror.h"
#include "winuser.h"
#include "ole2.h"
#include "oaidl.h"
#include "ocidl.h"
#include "mlang.h"
#include "shlwapi.h"
#include "docobj.h"
#include "shobjidl.h"
#include "shlobj.h"

Include dependency graph for ordinal.c:

Go to the source code of this file.

Classes
struct	SHELL_USER_SID
struct	SHELL_USER_PERMISSION
struct	call_entry_t
struct	call_trace_t
struct	shared_struct
struct	_disp
struct	_contain
struct	_cntptn
struct	_enum
struct	_enumpt
struct	_propbag
struct	IOleCommandTargetImpl
struct	IServiceProviderImpl
struct	IProfferServiceImpl< T >

Macros
#define	COBJMACROS
#define	CONST_VTABLE
#define	ok_trace(a, b)   ok_trace_(a, b, __LINE__)
#define	MY_INHERITANCE   0xBE /* invalid value to proof behavior */
#define	UNICODE_LTR_MARK   0x200e
#define	UNICODE_RTL_MARK   0x200f
#define	verify_inifile(f, e)   r_verify_inifile(__LINE__, f, e)
#define	MAKEFUNC(f, ord)   (p##f = (void*)GetProcAddress(hShlwapi, (LPSTR)(ord)))

Typedefs
typedef struct SHELL_USER_SID	SHELL_USER_SID
typedef struct SHELL_USER_SID *	PSHELL_USER_SID
typedef struct SHELL_USER_PERMISSION	SHELL_USER_PERMISSION
typedef struct SHELL_USER_PERMISSION *	PSHELL_USER_PERMISSION
typedef struct _disp	Disp
typedef struct _contain	Contain
typedef struct _cntptn	ConPt
typedef struct _enum	EnumCon
typedef struct _enumpt	EnumPt
typedef struct _propbag	PropBag

Enumerations
enum	_shellkey_flags {   SHKEY_Root_HKCU = 0x1 , SHKEY_Root_HKLM = 0x2 , SHKEY_Key_Explorer = 0x00 , SHKEY_Key_Shell = 0x10 ,   SHKEY_Key_ShellNoRoam = 0x20 , SHKEY_Key_Classes = 0x30 , SHKEY_Subkey_Default = 0x0000 , SHKEY_Subkey_ResourceName = 0x1000 ,   SHKEY_Subkey_Handlers = 0x2000 , SHKEY_Subkey_Associations = 0x3000 , SHKEY_Subkey_Volatile = 0x4000 , SHKEY_Subkey_MUICache = 0x5000 ,   SHKEY_Subkey_FileExts = 0x6000 , SHKEY_Root_HKCU = 0x1 , SHKEY_Root_HKLM = 0x2 , SHKEY_Key_Explorer = 0x00 ,   SHKEY_Key_Shell = 0x10 , SHKEY_Key_ShellNoRoam = 0x20 , SHKEY_Key_Classes = 0x30 , SHKEY_Subkey_Default = 0x0000 ,   SHKEY_Subkey_ResourceName = 0x1000 , SHKEY_Subkey_Handlers = 0x2000 , SHKEY_Subkey_Associations = 0x3000 , SHKEY_Subkey_Volatile = 0x4000 ,   SHKEY_Subkey_MUICache = 0x5000 , SHKEY_Subkey_FileExts = 0x6000 }

Functions
static	int (WINAPI *pSHSearchMapInt)(const int *
static	HRESULT (WINAPI *pGetAcceptLanguagesA)(LPSTR
static	HANDLE (WINAPI *pSHAllocShared)(LPCVOID
static	LPVOID (WINAPI *pSHLockShared)(HANDLE
static	BOOL (WINAPI *pSHUnlockShared)(LPVOID)
static	HRESULT (WINAPIV *pSHPackDispParams)(DISPPARAMS *
static	LONG (WINAPI *pSHSetWindowBits)(HWND
static	INT (WINAPI *pSHFormatDateTimeA)(const FILETIME UNALIGNED *
static	DWORD (WINAPI *pSHGetObjectCompatFlags)(IUnknown *
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static	HWND (WINAPI *pSHCreateWorkerWindowA)(LONG
static	HKEY (WINAPI *pSHGetShellKey)(DWORD
static SECURITY_DESCRIPTOR *WINAPI *	pGetShellSecurityDescriptor (const SHELL_USER_PERMISSION **, int)
static int	strcmp_wa (LPCWSTR strw, const char *stra)
static void	init_call_trace (call_trace_t *ctrace)
static void	free_call_trace (const call_trace_t *ctrace)
static void	add_call (call_trace_t *ctrace, int id, const void *arg0, const void *arg1, const void *arg2, const void *arg3, const void *arg4)
static void	ok_trace_ (call_trace_t *texpected, call_trace_t *tgot, int line)
static void	test_GetAcceptLanguagesA (void)
static void	test_SHSearchMapInt (void)
static void	test_alloc_shared (int argc, char **argv)
static void	test_alloc_shared_remote (DWORD procid, HANDLE hmem)
static void	test_fdsa (void)
static void	test_GetShellSecurityDescriptor (void)
static void	test_SHPackDispParams (void)
static Disp *	impl_from_IDispatch (IDispatch *iface)
static Contain *	impl_from_IConnectionPointContainer (IConnectionPointContainer *iface)
static ConPt *	impl_from_IConnectionPoint (IConnectionPoint *iface)
static EnumCon *	impl_from_IEnumConnections (IEnumConnections *iface)
static EnumPt *	impl_from_IEnumConnectionPoints (IEnumConnectionPoints *iface)
static HRESULT WINAPI	Disp_QueryInterface (IDispatch *This, REFIID riid, void **ppvObject)
static ULONG WINAPI	Disp_AddRef (IDispatch *This)
static ULONG WINAPI	Disp_Release (IDispatch *This)
static HRESULT WINAPI	Disp_GetTypeInfoCount (IDispatch *This, UINT *pctinfo)
static HRESULT WINAPI	Disp_GetTypeInfo (IDispatch *This, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	Disp_GetIDsOfNames (IDispatch *This, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	Disp_Invoke (IDispatch *This, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	Enum_QueryInterface (IEnumConnections *This, REFIID riid, void **ppvObject)
static ULONG WINAPI	Enum_AddRef (IEnumConnections *This)
static ULONG WINAPI	Enum_Release (IEnumConnections *This)
static HRESULT WINAPI	Enum_Next (IEnumConnections *This, ULONG cConnections, LPCONNECTDATA rgcd, ULONG *pcFetched)
static HRESULT WINAPI	Enum_Skip (IEnumConnections *This, ULONG cConnections)
static HRESULT WINAPI	Enum_Reset (IEnumConnections *This)
static HRESULT WINAPI	Enum_Clone (IEnumConnections *This, IEnumConnections **ppEnum)
static HRESULT WINAPI	ConPt_QueryInterface (IConnectionPoint *This, REFIID riid, void **ppvObject)
static ULONG WINAPI	ConPt_AddRef (IConnectionPoint *This)
static ULONG WINAPI	ConPt_Release (IConnectionPoint *This)
static HRESULT WINAPI	ConPt_GetConnectionInterface (IConnectionPoint *This, IID *pIID)
static HRESULT WINAPI	ConPt_GetConnectionPointContainer (IConnectionPoint *This, IConnectionPointContainer **ppCPC)
static HRESULT WINAPI	ConPt_Advise (IConnectionPoint *This, IUnknown *pUnkSink, DWORD *pdwCookie)
static HRESULT WINAPI	ConPt_Unadvise (IConnectionPoint *This, DWORD dwCookie)
static HRESULT WINAPI	ConPt_EnumConnections (IConnectionPoint *This, IEnumConnections **ppEnum)
static HRESULT WINAPI	EnumPt_QueryInterface (IEnumConnectionPoints *This, REFIID riid, void **ppvObject)
static ULONG WINAPI	EnumPt_AddRef (IEnumConnectionPoints *This)
static ULONG WINAPI	EnumPt_Release (IEnumConnectionPoints *This)
static HRESULT WINAPI	EnumPt_Next (IEnumConnectionPoints *This, ULONG cConnections, IConnectionPoint **rgcd, ULONG *pcFetched)
static HRESULT WINAPI	EnumPt_Skip (IEnumConnectionPoints *This, ULONG cConnections)
static HRESULT WINAPI	EnumPt_Reset (IEnumConnectionPoints *This)
static HRESULT WINAPI	EnumPt_Clone (IEnumConnectionPoints *This, IEnumConnectionPoints **ppEnumPt)
static HRESULT WINAPI	Contain_QueryInterface (IConnectionPointContainer *This, REFIID riid, void **ppvObject)
static ULONG WINAPI	Contain_AddRef (IConnectionPointContainer *This)
static ULONG WINAPI	Contain_Release (IConnectionPointContainer *This)
static HRESULT WINAPI	Contain_EnumConnectionPoints (IConnectionPointContainer *This, IEnumConnectionPoints **ppEnum)
static HRESULT WINAPI	Contain_FindConnectionPoint (IConnectionPointContainer *This, REFIID riid, IConnectionPoint **ppCP)
static void	test_IConnectionPoint (void)
static PropBag *	impl_from_IPropertyBag (IPropertyBag *iface)
static HRESULT WINAPI	Prop_QueryInterface (IPropertyBag *This, REFIID riid, void **ppvObject)
static ULONG WINAPI	Prop_AddRef (IPropertyBag *This)
static ULONG WINAPI	Prop_Release (IPropertyBag *This)
static HRESULT WINAPI	Prop_Read (IPropertyBag *This, LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog)
static HRESULT WINAPI	Prop_Write (IPropertyBag *This, LPCOLESTR pszPropName, VARIANT *pVar)
static void	test_SHPropertyBag_ReadLONG (void)
static void	test_SHSetWindowBits (void)
static void	test_SHFormatDateTimeA (void)
static void	test_SHFormatDateTimeW (void)
static void	test_SHGetObjectCompatFlags (void)
static IOleCommandTargetImpl *	impl_from_IOleCommandTarget (IOleCommandTarget *iface)
static IOleCommandTarget *	IOleCommandTargetImpl_Construct (void)
static HRESULT WINAPI	IOleCommandTargetImpl_QueryInterface (IOleCommandTarget *iface, REFIID riid, void **ppvObj)
static ULONG WINAPI	IOleCommandTargetImpl_AddRef (IOleCommandTarget *iface)
static ULONG WINAPI	IOleCommandTargetImpl_Release (IOleCommandTarget *iface)
static HRESULT WINAPI	IOleCommandTargetImpl_QueryStatus (IOleCommandTarget *iface, const GUID *group, ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
static HRESULT WINAPI	IOleCommandTargetImpl_Exec (IOleCommandTarget *iface, const GUID *CmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
static IServiceProviderImpl *	impl_from_IServiceProvider (IServiceProvider *iface)
static IProfferServiceImpl *	impl_from_IProfferService (IProfferService *iface)
static IServiceProvider *	IServiceProviderImpl_Construct (void)
static IProfferService *	IProfferServiceImpl_Construct (void)
static HRESULT WINAPI	IServiceProviderImpl_QueryInterface (IServiceProvider *iface, REFIID riid, void **ppvObj)
static ULONG WINAPI	IServiceProviderImpl_AddRef (IServiceProvider *iface)
static ULONG WINAPI	IServiceProviderImpl_Release (IServiceProvider *iface)
static HRESULT WINAPI	IServiceProviderImpl_QueryService (IServiceProvider *iface, REFGUID service, REFIID riid, void **ppv)
static void	test_IUnknown_QueryServiceExec (void)
static HRESULT WINAPI	IProfferServiceImpl_QueryInterface (IProfferService *iface, REFIID riid, void **ppvObj)
static ULONG WINAPI	IProfferServiceImpl_AddRef (IProfferService *iface)
static ULONG WINAPI	IProfferServiceImpl_Release (IProfferService *iface)
static HRESULT WINAPI	IProfferServiceImpl_ProfferService (IProfferService *iface, REFGUID service, IServiceProvider *pService, DWORD *pCookie)
static HRESULT WINAPI	IProfferServiceImpl_RevokeService (IProfferService *iface, DWORD cookie)
static void	test_IUnknown_ProfferService (void)
static void	test_SHCreateWorkerWindowA (void)
static HRESULT WINAPI	SF_QueryInterface (IShellFolder *iface, REFIID riid, void **ppv)
static ULONG WINAPI	SF_AddRef (IShellFolder *iface)
static ULONG WINAPI	SF_Release (IShellFolder *iface)
static HRESULT WINAPI	SF_ParseDisplayName (IShellFolder *iface, HWND owner, LPBC reserved, LPOLESTR displayName, ULONG *eaten, LPITEMIDLIST *idl, ULONG *attr)
static HRESULT WINAPI	SF_EnumObjects (IShellFolder *iface, HWND owner, SHCONTF flags, IEnumIDList **enm)
static HRESULT WINAPI	SF_BindToObject (IShellFolder *iface, LPCITEMIDLIST idl, LPBC reserved, REFIID riid, void **obj)
static HRESULT WINAPI	SF_BindToStorage (IShellFolder *iface, LPCITEMIDLIST idl, LPBC reserved, REFIID riid, void **obj)
static HRESULT WINAPI	SF_CompareIDs (IShellFolder *iface, LPARAM lparam, LPCITEMIDLIST idl1, LPCITEMIDLIST idl2)
static HRESULT WINAPI	SF_CreateViewObject (IShellFolder *iface, HWND owner, REFIID riid, void **out)
static HRESULT WINAPI	SF_GetAttributesOf (IShellFolder *iface, UINT cidl, LPCITEMIDLIST *idl, SFGAOF *inOut)
static HRESULT WINAPI	SF_GetUIObjectOf (IShellFolder *iface, HWND owner, UINT cidl, LPCITEMIDLIST *idls, REFIID riid, UINT *inOut, void **out)
static HRESULT WINAPI	SF_GetDisplayNameOf (IShellFolder *iface, LPCITEMIDLIST idl, SHGDNF flags, STRRET *name)
static HRESULT WINAPI	SF_SetNameOf (IShellFolder *iface, HWND hwnd, LPCITEMIDLIST idl, LPCOLESTR name, SHGDNF flags, LPITEMIDLIST *idlOut)
static void	test_SHIShellFolder_EnumObjects (void)
static BOOL	write_inifile (LPCWSTR filename)
static void	r_verify_inifile (unsigned l, LPCWSTR filename, LPCSTR exp)
static void	test_SHGetIniString (void)
static void	test_SHSetIniString (void)
static void	test_SHGetShellKey (void)
static void	init_pointers (void)
static void	test_SHSetParentHwnd (void)
static HRESULT WINAPI	testpersist_QI (IPersist *iface, REFIID riid, void **obj)
static HRESULT WINAPI	testpersist_QI2 (IPersist *iface, REFIID riid, void **obj)
static ULONG WINAPI	testpersist_AddRef (IPersist *iface)
static ULONG WINAPI	testpersist_Release (IPersist *iface)
static HRESULT WINAPI	testpersist_GetClassID (IPersist *iface, CLSID *clsid)
static void	test_IUnknown_GetClassID (void)
static void	test_DllGetVersion (void)
	START_TEST (ordinal)

Variables
static HMODULE	hShlwapi
static const int	int
static	LPDWORD
static	DWORD
static VARIANTARG	UINT
static VARIANTARG static	DISPID
static	REFIID
static	BOOL
static IUnknown IConnectionPoint **static	LPCWSTR
static IUnknown IConnectionPoint **static	LPLONG
static	INT
static DWORD	LPSTR
static DWORD	LPWSTR
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static	REFGUID
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static	HWND
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static	HMENU
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static	LONG_PTR
static	SHCONTF
static const CHAR	ie_international []
static const CHAR	acceptlanguage []
static call_trace_t	trace_got
static const IDispatchVtbl	disp_vtbl
static const IEnumConnectionsVtbl	enum_vtbl
static const IConnectionPointVtbl	point_vtbl
static const IEnumConnectionPointsVtbl	enumpt_vtbl
static const IConnectionPointContainerVtbl	contain_vtbl
static const IPropertyBagVtbl	prop_vtbl
static const IOleCommandTargetVtbl	IOleCommandTargetImpl_Vtbl
static const IServiceProviderVtbl	IServiceProviderImpl_Vtbl
static const IProfferServiceVtbl	IProfferServiceImpl_Vtbl
static IShellFolderVtbl	ShellFolderVtbl
static IShellFolder	ShellFolder = { &ShellFolderVtbl }
static IPersistVtbl	testpersistvtbl
static IPersistVtbl	testpersist2vtbl
static IPersist	testpersist = { &testpersistvtbl }
static IPersist	testpersist2 = { &testpersist2vtbl }

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 22 of file ordinal.c.

CONST_VTABLE

#define CONST_VTABLE

Definition at line 23 of file ordinal.c.

MAKEFUNC

#define MAKEFUNC	(		f,
			ord
	)		(p##f = (void*)GetProcAddress(hShlwapi, (LPSTR)(ord)))

MY_INHERITANCE

#define MY_INHERITANCE   0xBE /* invalid value to proof behavior */

ok_trace

#define ok_trace	(		a,
			b
	)		ok_trace_(a, b, __LINE__)

Definition at line 177 of file ordinal.c.

UNICODE_LTR_MARK

#define UNICODE_LTR_MARK   0x200e

UNICODE_RTL_MARK

#define UNICODE_RTL_MARK   0x200f

verify_inifile

#define verify_inifile	(		f,
			e
	)		r_verify_inifile(__LINE__, f, e)

Definition at line 2696 of file ordinal.c.

Typedef Documentation

ConPt

typedef struct _cntptn ConPt

Contain

typedef struct _contain Contain

Disp

typedef struct _disp Disp

EnumCon

typedef struct _enum EnumCon

EnumPt

typedef struct _enumpt EnumPt

PropBag

typedef struct _propbag PropBag

PSHELL_USER_PERMISSION

typedef struct SHELL_USER_PERMISSION * PSHELL_USER_PERMISSION

PSHELL_USER_SID

typedef struct SHELL_USER_SID * PSHELL_USER_SID

SHELL_USER_PERMISSION

typedef struct SHELL_USER_PERMISSION SHELL_USER_PERMISSION

SHELL_USER_SID

typedef struct SHELL_USER_SID SHELL_USER_SID

Enumeration Type Documentation

_shellkey_flags

enum _shellkey_flags

Enumerator
SHKEY_Root_HKCU
SHKEY_Root_HKLM
SHKEY_Key_Explorer
SHKEY_Key_Shell
SHKEY_Key_ShellNoRoam
SHKEY_Key_Classes
SHKEY_Subkey_Default
SHKEY_Subkey_ResourceName
SHKEY_Subkey_Handlers
SHKEY_Subkey_Associations
SHKEY_Subkey_Volatile
SHKEY_Subkey_MUICache
SHKEY_Subkey_FileExts
SHKEY_Root_HKCU
SHKEY_Root_HKLM
SHKEY_Key_Explorer
SHKEY_Key_Shell
SHKEY_Key_ShellNoRoam
SHKEY_Key_Classes
SHKEY_Subkey_Default
SHKEY_Subkey_ResourceName
SHKEY_Subkey_Handlers
SHKEY_Subkey_Associations
SHKEY_Subkey_Volatile
SHKEY_Subkey_MUICache
SHKEY_Subkey_FileExts

Definition at line 2803 of file ordinal.c.

                     {
    SHKEY_Root_HKCU = 0x1,
    SHKEY_Root_HKLM = 0x2,
    SHKEY_Key_Explorer  = 0x00,
    SHKEY_Key_Shell = 0x10,
    SHKEY_Key_ShellNoRoam = 0x20,
    SHKEY_Key_Classes = 0x30,
    SHKEY_Subkey_Default = 0x0000,
    SHKEY_Subkey_ResourceName = 0x1000,
    SHKEY_Subkey_Handlers = 0x2000,
    SHKEY_Subkey_Associations = 0x3000,
    SHKEY_Subkey_Volatile = 0x4000,
    SHKEY_Subkey_MUICache = 0x5000,
    SHKEY_Subkey_FileExts = 0x6000
};

Function Documentation

add_call()

static void add_call ( call_trace_t *  ctrace, int  id, const void *  arg0, const void *  arg1, const void *  arg2, const void *  arg3, const void *  arg4  )

static

Definition at line 131 of file ordinal.c.

{
    call_entry_t call;
 
    call.id = id;
    call.args[0] = arg0;
    call.args[1] = arg1;
    call.args[2] = arg2;
    call.args[3] = arg3;
    call.args[4] = arg4;
 
    if (ctrace->count == ctrace->alloc)
    {
        ctrace->alloc *= 2;
        ctrace->calls = HeapReAlloc(GetProcessHeap(),0, ctrace->calls, ctrace->alloc*sizeof(call_entry_t));
    }
 
    ctrace->calls[ctrace->count++] = call;
}

Referenced by IOleCommandTargetImpl_Exec(), IProfferServiceImpl_ProfferService(), IProfferServiceImpl_QueryInterface(), IProfferServiceImpl_RevokeService(), IServiceProviderImpl_QueryInterface(), IServiceProviderImpl_QueryService(), test_IUnknown_ProfferService(), and test_IUnknown_QueryServiceExec().

BOOL()

static BOOL ( WINAPI *  pSHUnlockShared )

static

ConPt_AddRef()

static ULONG WINAPI ConPt_AddRef ( IConnectionPoint *  This )

static

Definition at line 1130 of file ordinal.c.

{
    ConPt *iface = impl_from_IConnectionPoint(This);
    return InterlockedIncrement(&iface->refCount);
}

ConPt_Advise()

static HRESULT WINAPI ConPt_Advise ( IConnectionPoint *  This, IUnknown *  pUnkSink, DWORD *  pdwCookie  )

static

Definition at line 1187 of file ordinal.c.

{
    ConPt *iface = impl_from_IConnectionPoint(This);
 
    if (iface->sinkCount == 0)
        iface->sink = HeapAlloc(GetProcessHeap(),0,sizeof(IUnknown*));
    else
        iface->sink = HeapReAlloc(GetProcessHeap(),0,iface->sink,sizeof(IUnknown*)*(iface->sinkCount+1));
    iface->sink[iface->sinkCount] = pUnkSink;
    IUnknown_AddRef(pUnkSink);
    iface->sinkCount++;
    *pdwCookie = iface->sinkCount;
    return S_OK;
}

ConPt_EnumConnections()

static HRESULT WINAPI ConPt_EnumConnections ( IConnectionPoint *  This, IEnumConnections **  ppEnum  )

static

Definition at line 1221 of file ordinal.c.

{
    EnumCon *ec;
 
    ec = HeapAlloc(GetProcessHeap(),0,sizeof(EnumCon));
    ec->IEnumConnections_iface.lpVtbl = &enum_vtbl;
    ec->refCount = 1;
    ec->pt = impl_from_IConnectionPoint(This);
    ec->idx = 0;
    *ppEnum = &ec->IEnumConnections_iface;
 
    return S_OK;
}

ConPt_GetConnectionInterface()

static HRESULT WINAPI ConPt_GetConnectionInterface ( IConnectionPoint *  This, IID *  pIID  )

static

Definition at line 1161 of file ordinal.c.

{
    static int i = 0;
    ConPt *iface = impl_from_IConnectionPoint(This);
    if (i==0)
    {
        i++;
        return E_FAIL;
    }
    else
        memcpy(pIID,&iface->id,sizeof(GUID));
    return S_OK;
}

ConPt_GetConnectionPointContainer()

static HRESULT WINAPI ConPt_GetConnectionPointContainer ( IConnectionPoint *  This, IConnectionPointContainer **  ppCPC  )

static

Definition at line 1177 of file ordinal.c.

{
    ConPt *iface = impl_from_IConnectionPoint(This);
 
    *ppCPC = &iface->container->IConnectionPointContainer_iface;
    return S_OK;
}

ConPt_QueryInterface()

static HRESULT WINAPI ConPt_QueryInterface ( IConnectionPoint *  This, REFIID  riid, void **  ppvObject  )

static

Definition at line 1108 of file ordinal.c.

{
    *ppvObject = NULL;
 
    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IConnectionPoint))
    {
        *ppvObject = This;
    }
 
    if (*ppvObject)
    {
        IConnectionPoint_AddRef(This);
        return S_OK;
    }
 
    trace("no interface\n");
    return E_NOINTERFACE;
}

ConPt_Release()

static ULONG WINAPI ConPt_Release ( IConnectionPoint *  This )

static

Definition at line 1137 of file ordinal.c.

{
    ConPt *iface = impl_from_IConnectionPoint(This);
    ULONG ret;
 
    ret = InterlockedDecrement(&iface->refCount);
    if (ret == 0)
    {
        if (iface->sinkCount > 0)
        {
            int i;
            for (i = 0; i < iface->sinkCount; i++)
            {
                if (iface->sink[i])
                    IUnknown_Release(iface->sink[i]);
            }
            HeapFree(GetProcessHeap(),0,iface->sink);
        }
        HeapFree(GetProcessHeap(),0,This);
    }
    return ret;
}

ConPt_Unadvise()

static HRESULT WINAPI ConPt_Unadvise ( IConnectionPoint *  This, DWORD  dwCookie  )

static

Definition at line 1205 of file ordinal.c.

{
    ConPt *iface = impl_from_IConnectionPoint(This);
 
    if (dwCookie > iface->sinkCount)
        return E_FAIL;
    else
    {
        IUnknown_Release(iface->sink[dwCookie-1]);
        iface->sink[dwCookie-1] = NULL;
    }
    return S_OK;
}

Contain_AddRef()

static ULONG WINAPI Contain_AddRef ( IConnectionPointContainer *  This )

static

Definition at line 1362 of file ordinal.c.

{
    Contain *iface = impl_from_IConnectionPointContainer(This);
    return InterlockedIncrement(&iface->refCount);
}

Contain_EnumConnectionPoints()

static HRESULT WINAPI Contain_EnumConnectionPoints ( IConnectionPointContainer *  This, IEnumConnectionPoints **  ppEnum  )

static

Definition at line 1390 of file ordinal.c.

{
    EnumPt *ec;
 
    ec = HeapAlloc(GetProcessHeap(),0,sizeof(EnumPt));
    ec->IEnumConnectionPoints_iface.lpVtbl = &enumpt_vtbl;
    ec->refCount = 1;
    ec->idx= 0;
    ec->container = impl_from_IConnectionPointContainer(This);
    *ppEnum = &ec->IEnumConnectionPoints_iface;
 
    return S_OK;
}

Contain_FindConnectionPoint()

static HRESULT WINAPI Contain_FindConnectionPoint ( IConnectionPointContainer *  This, REFIID  riid, IConnectionPoint **  ppCP  )

static

Definition at line 1406 of file ordinal.c.

{
    Contain *iface = impl_from_IConnectionPointContainer(This);
    ConPt *pt;
 
    if (!IsEqualIID(riid, &IID_NULL) || iface->ptCount ==0)
    {
        pt = HeapAlloc(GetProcessHeap(),0,sizeof(ConPt));
        pt->IConnectionPoint_iface.lpVtbl = &point_vtbl;
        pt->refCount = 1;
        pt->sinkCount = 0;
        pt->sink = NULL;
        pt->container = iface;
        pt->id = IID_IDispatch;
 
        if (iface->ptCount == 0)
            iface->pt =HeapAlloc(GetProcessHeap(),0,sizeof(IUnknown*));
        else
            iface->pt = HeapReAlloc(GetProcessHeap(),0,iface->pt,sizeof(IUnknown*)*(iface->ptCount+1));
        iface->pt[iface->ptCount] = &pt->IConnectionPoint_iface;
        iface->ptCount++;
 
        *ppCP = &pt->IConnectionPoint_iface;
    }
    else
    {
        *ppCP = iface->pt[0];
        IUnknown_AddRef((IUnknown*)*ppCP);
    }
 
    return S_OK;
}

Contain_QueryInterface()

static HRESULT WINAPI Contain_QueryInterface ( IConnectionPointContainer *  This, REFIID  riid, void **  ppvObject  )

static

Definition at line 1340 of file ordinal.c.

{
    *ppvObject = NULL;
 
    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IConnectionPointContainer))
    {
        *ppvObject = This;
    }
 
    if (*ppvObject)
    {
        IConnectionPointContainer_AddRef(This);
        return S_OK;
    }
 
    trace("no interface\n");
    return E_NOINTERFACE;
}

Contain_Release()

static ULONG WINAPI Contain_Release ( IConnectionPointContainer *  This )

static

Definition at line 1369 of file ordinal.c.

{
    Contain *iface = impl_from_IConnectionPointContainer(This);
    ULONG ret;
 
    ret = InterlockedDecrement(&iface->refCount);
    if (ret == 0)
    {
        if (iface->ptCount > 0)
        {
            int i;
            for (i = 0; i < iface->ptCount; i++)
                IConnectionPoint_Release(iface->pt[i]);
            HeapFree(GetProcessHeap(),0,iface->pt);
        }
        HeapFree(GetProcessHeap(),0,This);
    }
    return ret;
}

Disp_AddRef()

static ULONG WINAPI Disp_AddRef ( IDispatch *  This )

static

Definition at line 922 of file ordinal.c.

{
    Disp *iface = impl_from_IDispatch(This);
    return InterlockedIncrement(&iface->refCount);
}

Disp_GetIDsOfNames()

static HRESULT WINAPI Disp_GetIDsOfNames ( IDispatch *  This, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 955 of file ordinal.c.

{
    return ERROR_SUCCESS;
}

Disp_GetTypeInfo()

static HRESULT WINAPI Disp_GetTypeInfo ( IDispatch *  This, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 946 of file ordinal.c.

{
    return ERROR_SUCCESS;
}

Disp_GetTypeInfoCount()

static HRESULT WINAPI Disp_GetTypeInfoCount ( IDispatch *  This, UINT *  pctinfo  )

static

Definition at line 939 of file ordinal.c.

{
    return ERROR_SUCCESS;
}

Disp_Invoke()

static HRESULT WINAPI Disp_Invoke ( IDispatch *  This, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 966 of file ordinal.c.

{
    trace("%p %x %s %x %x %p %p %p %p\n", This, dispIdMember, wine_dbgstr_guid(riid), lcid, wFlags,
          pDispParams, pVarResult, pExcepInfo, puArgErr);
 
    ok(dispIdMember == 0xa0 || dispIdMember == 0xa1, "Unknown dispIdMember\n");
    ok(pDispParams != NULL, "Invoked with NULL pDispParams\n");
    ok(wFlags == DISPATCH_METHOD, "Wrong flags %x\n",wFlags);
    ok(lcid == 0,"Wrong lcid %x\n",lcid);
    if (dispIdMember == 0xa0)
    {
        ok(pDispParams->cArgs == 0, "params.cArgs = %d\n", pDispParams->cArgs);
        ok(pDispParams->cNamedArgs == 0, "params.cNamedArgs = %d\n", pDispParams->cArgs);
        ok(pDispParams->rgdispidNamedArgs == NULL, "params.rgdispidNamedArgs = %p\n", pDispParams->rgdispidNamedArgs);
        ok(pDispParams->rgvarg == NULL, "params.rgvarg = %p\n", pDispParams->rgvarg);
    }
    else if (dispIdMember == 0xa1)
    {
        ok(pDispParams->cArgs == 2, "params.cArgs = %d\n", pDispParams->cArgs);
        ok(pDispParams->cNamedArgs == 0, "params.cNamedArgs = %d\n", pDispParams->cArgs);
        ok(pDispParams->rgdispidNamedArgs == NULL, "params.rgdispidNamedArgs = %p\n", pDispParams->rgdispidNamedArgs);
        ok(V_VT(pDispParams->rgvarg) == VT_BSTR, "V_VT(var) = %d\n", V_VT(pDispParams->rgvarg));
        ok(V_I4(pDispParams->rgvarg) == 0xdeadcafe , "failed %p\n", V_BSTR(pDispParams->rgvarg));
        ok(V_VT(pDispParams->rgvarg+1) == VT_I4, "V_VT(var) = %d\n", V_VT(pDispParams->rgvarg+1));
        ok(V_I4(pDispParams->rgvarg+1) == 0xdeadbeef, "failed %x\n", V_I4(pDispParams->rgvarg+1));
    }
 
    return ERROR_SUCCESS;
}

Disp_QueryInterface()

static HRESULT WINAPI Disp_QueryInterface ( IDispatch *  This, REFIID  riid, void **  ppvObject  )

static

Definition at line 900 of file ordinal.c.

{
    *ppvObject = NULL;
 
    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
    {
        *ppvObject = This;
    }
 
    if (*ppvObject)
    {
        IDispatch_AddRef(This);
        return S_OK;
    }
 
    trace("no interface\n");
    return E_NOINTERFACE;
}

Disp_Release()

static ULONG WINAPI Disp_Release ( IDispatch *  This )

static

Definition at line 928 of file ordinal.c.

{
    Disp *iface = impl_from_IDispatch(This);
    ULONG ret;
 
    ret = InterlockedDecrement(&iface->refCount);
    if (ret == 0)
        HeapFree(GetProcessHeap(),0,This);
    return ret;
}

DWORD()

static DWORD ( WINAPI *  pSHGetObjectCompatFlags )

static

Enum_AddRef()

static ULONG WINAPI Enum_AddRef ( IEnumConnections *  This )

static

Definition at line 1038 of file ordinal.c.

{
    EnumCon *iface = impl_from_IEnumConnections(This);
    return InterlockedIncrement(&iface->refCount);
}

Enum_Clone()

static HRESULT WINAPI Enum_Clone ( IEnumConnections *  This, IEnumConnections **  ppEnum  )

static

Definition at line 1090 of file ordinal.c.

{
    return E_FAIL;
}

Enum_Next()

static HRESULT WINAPI Enum_Next ( IEnumConnections *  This, ULONG  cConnections, LPCONNECTDATA  rgcd, ULONG *  pcFetched  )

static

Definition at line 1055 of file ordinal.c.

{
    EnumCon *iface = impl_from_IEnumConnections(This);
 
    if (cConnections > 0 && iface->idx < iface->pt->sinkCount)
    {
        rgcd->pUnk = iface->pt->sink[iface->idx];
        IUnknown_AddRef(iface->pt->sink[iface->idx]);
        rgcd->dwCookie=0xff;
        if (pcFetched)
            *pcFetched = 1;
        iface->idx++;
        return S_OK;
    }
 
    return E_FAIL;
}

Enum_QueryInterface()

static HRESULT WINAPI Enum_QueryInterface ( IEnumConnections *  This, REFIID  riid, void **  ppvObject  )

static

Definition at line 1016 of file ordinal.c.

{
    *ppvObject = NULL;
 
    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IEnumConnections))
    {
        *ppvObject = This;
    }
 
    if (*ppvObject)
    {
        IEnumConnections_AddRef(This);
        return S_OK;
    }
 
    trace("no interface\n");
    return E_NOINTERFACE;
}

Enum_Release()

static ULONG WINAPI Enum_Release ( IEnumConnections *  This )

static

Definition at line 1044 of file ordinal.c.

{
    EnumCon *iface = impl_from_IEnumConnections(This);
    ULONG ret;
 
    ret = InterlockedDecrement(&iface->refCount);
    if (ret == 0)
        HeapFree(GetProcessHeap(),0,This);
    return ret;
}

Enum_Reset()

static HRESULT WINAPI Enum_Reset ( IEnumConnections *  This )

static

Definition at line 1084 of file ordinal.c.

{
    return E_FAIL;
}

Enum_Skip()

static HRESULT WINAPI Enum_Skip ( IEnumConnections *  This, ULONG  cConnections  )

static

Definition at line 1077 of file ordinal.c.

{
    return E_FAIL;
}

EnumPt_AddRef()

static ULONG WINAPI EnumPt_AddRef ( IEnumConnectionPoints *  This )

static

Definition at line 1271 of file ordinal.c.

{
    EnumPt *iface = impl_from_IEnumConnectionPoints(This);
    return InterlockedIncrement(&iface->refCount);
}

EnumPt_Clone()

static HRESULT WINAPI EnumPt_Clone ( IEnumConnectionPoints *  This, IEnumConnectionPoints **  ppEnumPt  )

static

Definition at line 1322 of file ordinal.c.

{
    return E_FAIL;
}

EnumPt_Next()

static HRESULT WINAPI EnumPt_Next ( IEnumConnectionPoints *  This, ULONG  cConnections, IConnectionPoint **  rgcd, ULONG *  pcFetched  )

static

Definition at line 1288 of file ordinal.c.

{
    EnumPt *iface = impl_from_IEnumConnectionPoints(This);
 
    if (cConnections > 0 && iface->idx < iface->container->ptCount)
    {
        *rgcd = iface->container->pt[iface->idx];
        IConnectionPoint_AddRef(iface->container->pt[iface->idx]);
        if (pcFetched)
            *pcFetched = 1;
        iface->idx++;
        return S_OK;
    }
 
    return E_FAIL;
}

EnumPt_QueryInterface()

static HRESULT WINAPI EnumPt_QueryInterface ( IEnumConnectionPoints *  This, REFIID  riid, void **  ppvObject  )

static

Definition at line 1249 of file ordinal.c.

{
    *ppvObject = NULL;
 
    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IEnumConnectionPoints))
    {
        *ppvObject = This;
    }
 
    if (*ppvObject)
    {
        IEnumConnectionPoints_AddRef(This);
        return S_OK;
    }
 
    trace("no interface\n");
    return E_NOINTERFACE;
}

EnumPt_Release()

static ULONG WINAPI EnumPt_Release ( IEnumConnectionPoints *  This )

static

Definition at line 1277 of file ordinal.c.

{
    EnumPt *iface = impl_from_IEnumConnectionPoints(This);
    ULONG ret;
 
    ret = InterlockedDecrement(&iface->refCount);
    if (ret == 0)
        HeapFree(GetProcessHeap(),0,This);
    return ret;
}

EnumPt_Reset()

static HRESULT WINAPI EnumPt_Reset ( IEnumConnectionPoints *  This )

static

Definition at line 1316 of file ordinal.c.

{
    return E_FAIL;
}

EnumPt_Skip()

static HRESULT WINAPI EnumPt_Skip ( IEnumConnectionPoints *  This, ULONG  cConnections  )

static

Definition at line 1309 of file ordinal.c.

{
    return E_FAIL;
}

free_call_trace()

static void free_call_trace ( const call_trace_t *  ctrace )

static

Definition at line 126 of file ordinal.c.

{
    HeapFree(GetProcessHeap(), 0, ctrace->calls);
}

Referenced by test_IUnknown_ProfferService(), and test_IUnknown_QueryServiceExec().

HANDLE()

static HANDLE ( WINAPI *  pSHAllocShared )

static

HKEY()

static HKEY ( WINAPI *  pSHGetShellKey )

static

HRESULT() [1/2]

static HRESULT ( WINAPI *  pGetAcceptLanguagesA )

static

HRESULT() [2/2]

static HRESULT ( WINAPIV *  pSHPackDispParams )

static

HWND()

static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HWND ( WINAPI *  pSHCreateWorkerWindowA )

static

impl_from_IConnectionPoint()

static ConPt * impl_from_IConnectionPoint ( IConnectionPoint *  iface )

inlinestatic

Definition at line 866 of file ordinal.c.

{
    return CONTAINING_RECORD(iface, ConPt, IConnectionPoint_iface);
}

Referenced by ConPt_AddRef(), ConPt_Advise(), ConPt_EnumConnections(), ConPt_GetConnectionInterface(), ConPt_GetConnectionPointContainer(), ConPt_Release(), and ConPt_Unadvise().

impl_from_IConnectionPointContainer()

static Contain * impl_from_IConnectionPointContainer ( IConnectionPointContainer *  iface )

inlinestatic

Definition at line 850 of file ordinal.c.

{
    return CONTAINING_RECORD(iface, Contain, IConnectionPointContainer_iface);
}

Referenced by Contain_AddRef(), Contain_EnumConnectionPoints(), Contain_FindConnectionPoint(), and Contain_Release().

impl_from_IDispatch()

static Disp * impl_from_IDispatch ( IDispatch *  iface )

inlinestatic

Definition at line 836 of file ordinal.c.

{
    return CONTAINING_RECORD(iface, Disp, IDispatch_iface);
}

Referenced by Disp_AddRef(), and Disp_Release().

impl_from_IEnumConnectionPoints()

static EnumPt * impl_from_IEnumConnectionPoints ( IEnumConnectionPoints *  iface )

inlinestatic

Definition at line 894 of file ordinal.c.

{
    return CONTAINING_RECORD(iface, EnumPt, IEnumConnectionPoints_iface);
}

Referenced by EnumPt_AddRef(), EnumPt_Next(), and EnumPt_Release().

impl_from_IEnumConnections()

static EnumCon * impl_from_IEnumConnections ( IEnumConnections *  iface )

inlinestatic

Definition at line 880 of file ordinal.c.

{
    return CONTAINING_RECORD(iface, EnumCon, IEnumConnections_iface);
}

Referenced by Enum_AddRef(), Enum_Next(), and Enum_Release().

impl_from_IOleCommandTarget()

static IOleCommandTargetImpl * impl_from_IOleCommandTarget ( IOleCommandTarget *  iface )

inlinestatic

Definition at line 2099 of file ordinal.c.

{
    return CONTAINING_RECORD(iface, IOleCommandTargetImpl, IOleCommandTarget_iface);
}

Referenced by IOleCommandTargetImpl_AddRef(), IOleCommandTargetImpl_QueryInterface(), and IOleCommandTargetImpl_Release().

impl_from_IProfferService()

static IProfferServiceImpl * impl_from_IProfferService ( IProfferService *  iface )

inlinestatic

Definition at line 2197 of file ordinal.c.

{
    return CONTAINING_RECORD(iface, IProfferServiceImpl, IProfferService_iface);
}

Referenced by IProfferServiceImpl_AddRef(), IProfferServiceImpl_QueryInterface(), and IProfferServiceImpl_Release().

impl_from_IPropertyBag()

static PropBag * impl_from_IPropertyBag ( IPropertyBag *  iface )

inlinestatic

Definition at line 1507 of file ordinal.c.

{
    return CONTAINING_RECORD(iface, PropBag, IPropertyBag_iface);
}

Referenced by Prop_AddRef(), and Prop_Release().

impl_from_IServiceProvider()

static IServiceProviderImpl * impl_from_IServiceProvider ( IServiceProvider *  iface )

inlinestatic

Definition at line 2187 of file ordinal.c.

{
    return CONTAINING_RECORD(iface, IServiceProviderImpl, IServiceProvider_iface);
}

Referenced by IServiceProviderImpl_AddRef(), IServiceProviderImpl_QueryInterface(), and IServiceProviderImpl_Release().

init_call_trace()

static void init_call_trace ( call_trace_t *  ctrace )

static

Definition at line 119 of file ordinal.c.

{
    ctrace->alloc = 10;
    ctrace->count = 0;
    ctrace->calls = HeapAlloc(GetProcessHeap(), 0, sizeof(call_entry_t) * ctrace->alloc);
}

Referenced by test_IUnknown_ProfferService(), and test_IUnknown_QueryServiceExec().

init_pointers()

static void init_pointers ( void  )

static

Definition at line 2910 of file ordinal.c.

{
#define MAKEFUNC(f, ord) (p##f = (void*)GetProcAddress(hShlwapi, (LPSTR)(ord)))
    MAKEFUNC(SHAllocShared, 7);
    MAKEFUNC(SHLockShared, 8);
    MAKEFUNC(SHUnlockShared, 9);
    MAKEFUNC(SHFreeShared, 10);
    MAKEFUNC(SHMapHandle, 11);
    MAKEFUNC(GetAcceptLanguagesA, 14);
    MAKEFUNC(SHSetWindowBits, 165);
    MAKEFUNC(SHSetParentHwnd, 167);
    MAKEFUNC(ConnectToConnectionPoint, 168);
    MAKEFUNC(IUnknown_GetClassID, 175);
    MAKEFUNC(SHSearchMapInt, 198);
    MAKEFUNC(SHCreateWorkerWindowA, 257);
    MAKEFUNC(GUIDFromStringA, 269);
    MAKEFUNC(SHPackDispParams, 282);
    MAKEFUNC(IConnectionPoint_InvokeWithCancel, 283);
    MAKEFUNC(IConnectionPoint_SimpleInvoke, 284);
    MAKEFUNC(SHGetIniStringW, 294);
    MAKEFUNC(SHSetIniStringW, 295);
    MAKEFUNC(SHFormatDateTimeA, 353);
    MAKEFUNC(SHFormatDateTimeW, 354);
    MAKEFUNC(SHIShellFolder_EnumObjects, 404);
    MAKEFUNC(GetShellSecurityDescriptor, 475);
    MAKEFUNC(SHGetObjectCompatFlags, 476);
    MAKEFUNC(IUnknown_QueryServiceExec, 484);
    MAKEFUNC(SHGetShellKey, 491);
    MAKEFUNC(SHPropertyBag_ReadLONG, 496);
    MAKEFUNC(IUnknown_ProfferService, 514);
    MAKEFUNC(SKGetValueW, 516);
    MAKEFUNC(SKSetValueW, 517);
    MAKEFUNC(SKDeleteValueW, 518);
    MAKEFUNC(SKAllocValueW, 519);
#undef MAKEFUNC
 
    pDllGetVersion = (void*)GetProcAddress(hShlwapi, "DllGetVersion");
}

Referenced by START_TEST().

INT()

static INT ( WINAPI *  pSHFormatDateTimeA ) const

static

int()

static int ( WINAPI *  pSHSearchMapInt ) const

static

IOleCommandTargetImpl_AddRef()

static ULONG WINAPI IOleCommandTargetImpl_AddRef ( IOleCommandTarget *  iface )

static

Definition at line 2136 of file ordinal.c.

{
    IOleCommandTargetImpl *This = impl_from_IOleCommandTarget(iface);
    return InterlockedIncrement(&This->ref);
}

IOleCommandTargetImpl_Construct()

static IOleCommandTarget * IOleCommandTargetImpl_Construct ( void  )

static

Definition at line 2106 of file ordinal.c.

{
    IOleCommandTargetImpl *obj;
 
    obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
    obj->IOleCommandTarget_iface.lpVtbl = &IOleCommandTargetImpl_Vtbl;
    obj->ref = 1;
 
    return &obj->IOleCommandTarget_iface;
}

Referenced by IServiceProviderImpl_QueryService().

IOleCommandTargetImpl_Exec()

static HRESULT WINAPI IOleCommandTargetImpl_Exec ( IOleCommandTarget *  iface, const GUID *  CmdGroup, DWORD  nCmdID, DWORD  nCmdexecopt, VARIANT *  pvaIn, VARIANT *  pvaOut  )

static

Definition at line 2161 of file ordinal.c.

{
    add_call(&trace_got, 3, CmdGroup, (void*)(DWORD_PTR)nCmdID, (void*)(DWORD_PTR)nCmdexecopt, pvaIn, pvaOut);
    return S_OK;
}

IOleCommandTargetImpl_QueryInterface()

static HRESULT WINAPI IOleCommandTargetImpl_QueryInterface ( IOleCommandTarget *  iface, REFIID  riid, void **  ppvObj  )

static

Definition at line 2117 of file ordinal.c.

{
    IOleCommandTargetImpl *This = impl_from_IOleCommandTarget(iface);
 
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IOleCommandTarget))
    {
        *ppvObj = This;
    }
 
    if(*ppvObj)
    {
        IOleCommandTarget_AddRef(iface);
        return S_OK;
    }
 
    return E_NOINTERFACE;
}

IOleCommandTargetImpl_QueryStatus()

static HRESULT WINAPI IOleCommandTargetImpl_QueryStatus ( IOleCommandTarget *  iface, const GUID *  group, ULONG  cCmds, OLECMD  prgCmds[], OLECMDTEXT *  pCmdText  )

static

Definition at line 2155 of file ordinal.c.

{
    return E_NOTIMPL;
}

IOleCommandTargetImpl_Release()

static ULONG WINAPI IOleCommandTargetImpl_Release ( IOleCommandTarget *  iface )

static

Definition at line 2142 of file ordinal.c.

{
    IOleCommandTargetImpl *This = impl_from_IOleCommandTarget(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    if (!ref)
    {
        HeapFree(GetProcessHeap(), 0, This);
        return 0;
    }
    return ref;
}

IProfferServiceImpl_AddRef()

static ULONG WINAPI IProfferServiceImpl_AddRef ( IProfferService *  iface )

static

Definition at line 2361 of file ordinal.c.

{
    IProfferServiceImpl *This = impl_from_IProfferService(iface);
    return InterlockedIncrement(&This->ref);
}

IProfferServiceImpl_Construct()

static IProfferService * IProfferServiceImpl_Construct ( void  )

static

Definition at line 2217 of file ordinal.c.

{
    IProfferServiceImpl *obj;
 
    obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
    obj->IProfferService_iface.lpVtbl = &IProfferServiceImpl_Vtbl;
    obj->ref = 1;
 
    return &obj->IProfferService_iface;
}

Referenced by IServiceProviderImpl_QueryService(), and test_IUnknown_ProfferService().

IProfferServiceImpl_ProfferService()

static HRESULT WINAPI IProfferServiceImpl_ProfferService ( IProfferService *  iface, REFGUID  service, IServiceProvider *  pService, DWORD *  pCookie  )

static

Definition at line 2380 of file ordinal.c.

{
    *pCookie = 0xdeadbeef;
    add_call(&trace_got, 3, service, pService, pCookie, 0, 0);
    return S_OK;
}

IProfferServiceImpl_QueryInterface()

static HRESULT WINAPI IProfferServiceImpl_QueryInterface ( IProfferService *  iface, REFIID  riid, void **  ppvObj  )

static

Definition at line 2336 of file ordinal.c.

{
    IProfferServiceImpl *This = impl_from_IProfferService(iface);
 
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IProfferService))
    {
        *ppvObj = This;
    }
    else if (IsEqualIID(riid, &IID_IServiceProvider))
    {
        *ppvObj = IServiceProviderImpl_Construct();
        add_call(&trace_got, 1, iface, &IID_IServiceProvider, 0, 0, 0);
        return S_OK;
    }
 
    if(*ppvObj)
    {
        IProfferService_AddRef(iface);
        return S_OK;
    }
 
    return E_NOINTERFACE;
}

IProfferServiceImpl_Release()

static ULONG WINAPI IProfferServiceImpl_Release ( IProfferService *  iface )

static

Definition at line 2367 of file ordinal.c.

{
    IProfferServiceImpl *This = impl_from_IProfferService(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    if (!ref)
    {
        HeapFree(GetProcessHeap(), 0, This);
        return 0;
    }
    return ref;
}

IProfferServiceImpl_RevokeService()

static HRESULT WINAPI IProfferServiceImpl_RevokeService ( IProfferService *  iface, DWORD  cookie  )

static

Definition at line 2388 of file ordinal.c.

{
    add_call(&trace_got, 4, (void*)(DWORD_PTR)cookie, 0, 0, 0, 0);
    return S_OK;
}

IServiceProviderImpl_AddRef()

static ULONG WINAPI IServiceProviderImpl_AddRef ( IServiceProvider *  iface )

static

Definition at line 2250 of file ordinal.c.

{
    IServiceProviderImpl *This = impl_from_IServiceProvider(iface);
    return InterlockedIncrement(&This->ref);
}

IServiceProviderImpl_Construct()

static IServiceProvider * IServiceProviderImpl_Construct ( void  )

static

Definition at line 2206 of file ordinal.c.

{
    IServiceProviderImpl *obj;
 
    obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
    obj->IServiceProvider_iface.lpVtbl = &IServiceProviderImpl_Vtbl;
    obj->ref = 1;
 
    return &obj->IServiceProvider_iface;
}

Referenced by IProfferServiceImpl_QueryInterface(), test_IUnknown_ProfferService(), and test_IUnknown_QueryServiceExec().

IServiceProviderImpl_QueryInterface()

static HRESULT WINAPI IServiceProviderImpl_QueryInterface ( IServiceProvider *  iface, REFIID  riid, void **  ppvObj  )

static

Definition at line 2228 of file ordinal.c.

{
    IServiceProviderImpl *This = impl_from_IServiceProvider(iface);
 
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IServiceProvider))
    {
        *ppvObj = This;
    }
 
    if(*ppvObj)
    {
        IServiceProvider_AddRef(iface);
        /* native uses redefined IID_IServiceProvider symbol, so we can't compare pointers */
        if (IsEqualIID(riid, &IID_IServiceProvider))
            add_call(&trace_got, 1, iface, &IID_IServiceProvider, 0, 0, 0);
        return S_OK;
    }
 
    return E_NOINTERFACE;
}

IServiceProviderImpl_QueryService()

static HRESULT WINAPI IServiceProviderImpl_QueryService ( IServiceProvider *  iface, REFGUID  service, REFIID  riid, void **  ppv  )

static

Definition at line 2269 of file ordinal.c.

{
    /* native uses redefined pointer for IID_IOleCommandTarget, not one from uuid.lib */
    if (IsEqualIID(riid, &IID_IOleCommandTarget))
    {
        add_call(&trace_got, 2, iface, service, &IID_IOleCommandTarget, 0, 0);
        *ppv = IOleCommandTargetImpl_Construct();
    }
    if (IsEqualIID(riid, &IID_IProfferService))
    {
        if (IsEqualIID(service, &IID_IProfferService))
            add_call(&trace_got, 2, &IID_IProfferService, &IID_IProfferService, 0, 0, 0);
        *ppv = IProfferServiceImpl_Construct();
    }
    return S_OK;
}

IServiceProviderImpl_Release()

static ULONG WINAPI IServiceProviderImpl_Release ( IServiceProvider *  iface )

static

Definition at line 2256 of file ordinal.c.

{
    IServiceProviderImpl *This = impl_from_IServiceProvider(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    if (!ref)
    {
        HeapFree(GetProcessHeap(), 0, This);
        return 0;
    }
    return ref;
}

LONG()

static LONG ( WINAPI *  pSHSetWindowBits )

static

LPVOID()

static LPVOID ( WINAPI *  pSHLockShared )

static

ok_trace_()

static void ok_trace_ ( call_trace_t *  texpected, call_trace_t *  tgot, int  line  )

static

Definition at line 152 of file ordinal.c.

{
    if (texpected->count == tgot->count)
    {
        INT i;
        /* compare */
        for (i = 0; i < texpected->count; i++)
        {
            call_entry_t *expected = &texpected->calls[i];
            call_entry_t *got = &tgot->calls[i];
            INT j;
 
            ok_(__FILE__, line)(expected->id == got->id, "got different ids %d: %d, %d\n", i+1, expected->id, got->id);
 
            for (j = 0; j < 5; j++)
            {
                ok_(__FILE__, line)(expected->args[j] == got->args[j], "got different args[%d] for %d: %p, %p\n", j, i+1,
                   expected->args[j], got->args[j]);
            }
        }
    }
    else
        ok_(__FILE__, line)(0, "traces length mismatch\n");
}

pGetShellSecurityDescriptor()

static SECURITY_DESCRIPTOR *WINAPI * pGetShellSecurityDescriptor ( const SHELL_USER_PERMISSION **  , int    )

static

Referenced by test_GetShellSecurityDescriptor().

Prop_AddRef()

static ULONG WINAPI Prop_AddRef ( IPropertyBag *  This )

static

Definition at line 1535 of file ordinal.c.

{
    PropBag *iface = impl_from_IPropertyBag(This);
    return InterlockedIncrement(&iface->refCount);
}

Prop_QueryInterface()

static HRESULT WINAPI Prop_QueryInterface ( IPropertyBag *  This, REFIID  riid, void **  ppvObject  )

static

Definition at line 1513 of file ordinal.c.

{
    *ppvObject = NULL;
 
    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IPropertyBag))
    {
        *ppvObject = This;
    }
 
    if (*ppvObject)
    {
        IPropertyBag_AddRef(This);
        return S_OK;
    }
 
    trace("no interface\n");
    return E_NOINTERFACE;
}

Prop_Read()

static HRESULT WINAPI Prop_Read ( IPropertyBag *  This, LPCOLESTR  pszPropName, VARIANT *  pVar, IErrorLog *  pErrorLog  )

static

Definition at line 1554 of file ordinal.c.

{
    V_VT(pVar) = VT_BLOB|VT_BYREF;
    V_BYREF(pVar) = (LPVOID)0xdeadcafe;
    return S_OK;
}

Prop_Release()

static ULONG WINAPI Prop_Release ( IPropertyBag *  This )

static

Definition at line 1542 of file ordinal.c.

{
    PropBag *iface = impl_from_IPropertyBag(This);
    ULONG ret;
 
    ret = InterlockedDecrement(&iface->refCount);
    if (ret == 0)
        HeapFree(GetProcessHeap(),0,This);
    return ret;
}

Prop_Write()

static HRESULT WINAPI Prop_Write ( IPropertyBag *  This, LPCOLESTR  pszPropName, VARIANT *  pVar  )

static

Definition at line 1565 of file ordinal.c.

{
    return S_OK;
}

r_verify_inifile()

static void r_verify_inifile ( unsigned  l, LPCWSTR  filename, LPCSTR  exp  )

static

Definition at line 2697 of file ordinal.c.

{
    HANDLE file;
    CHAR buf[1024];
    DWORD read;
 
    file = CreateFileW(filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
 
    if(file == INVALID_HANDLE_VALUE)
        return;
 
    ReadFile(file, buf, sizeof(buf) * sizeof(CHAR), &read, NULL);
    buf[read] = '\0';
 
    CloseHandle(file);
 
    ok_(__FILE__,l)(!strcmp(buf, exp), "Expected:\n%s\nGot:\n%s\n", exp,
            buf);
}

SF_AddRef()

static ULONG WINAPI SF_AddRef ( IShellFolder *  iface )

static

Definition at line 2528 of file ordinal.c.

{
    return 2;
}

SF_BindToObject()

static HRESULT WINAPI SF_BindToObject ( IShellFolder *  iface, LPCITEMIDLIST  idl, LPBC  reserved, REFIID  riid, void **  obj  )

static

Definition at line 2553 of file ordinal.c.

{
    ok(0, "Didn't expect BindToObject\n");
    return E_NOTIMPL;
}

SF_BindToStorage()

static HRESULT WINAPI SF_BindToStorage ( IShellFolder *  iface, LPCITEMIDLIST  idl, LPBC  reserved, REFIID  riid, void **  obj  )

static

Definition at line 2560 of file ordinal.c.

{
    ok(0, "Didn't expect BindToStorage\n");
    return E_NOTIMPL;
}

SF_CompareIDs()

static HRESULT WINAPI SF_CompareIDs ( IShellFolder *  iface, LPARAM  lparam, LPCITEMIDLIST  idl1, LPCITEMIDLIST  idl2  )

static

Definition at line 2567 of file ordinal.c.

{
    ok(0, "Didn't expect CompareIDs\n");
    return E_NOTIMPL;
}

SF_CreateViewObject()

static HRESULT WINAPI SF_CreateViewObject ( IShellFolder *  iface, HWND  owner, REFIID  riid, void **  out  )

static

Definition at line 2574 of file ordinal.c.

{
    ok(0, "Didn't expect CreateViewObject\n");
    return E_NOTIMPL;
}

SF_EnumObjects()

static HRESULT WINAPI SF_EnumObjects ( IShellFolder *  iface, HWND  owner, SHCONTF  flags, IEnumIDList **  enm  )

static

Definition at line 2546 of file ordinal.c.

{
    *enm = (IEnumIDList*)0xcafebabe;
    return S_OK;
}

SF_GetAttributesOf()

static HRESULT WINAPI SF_GetAttributesOf ( IShellFolder *  iface, UINT  cidl, LPCITEMIDLIST *  idl, SFGAOF *  inOut  )

static

Definition at line 2581 of file ordinal.c.

{
    ok(0, "Didn't expect GetAttributesOf\n");
    return E_NOTIMPL;
}

SF_GetDisplayNameOf()

static HRESULT WINAPI SF_GetDisplayNameOf ( IShellFolder *  iface, LPCITEMIDLIST  idl, SHGDNF  flags, STRRET *  name  )

static

Definition at line 2604 of file ordinal.c.

{
    ok(0, "Didn't expect GetDisplayNameOf\n");
    return E_NOTIMPL;
}

SF_GetUIObjectOf()

static HRESULT WINAPI SF_GetUIObjectOf ( IShellFolder *  iface, HWND  owner, UINT  cidl, LPCITEMIDLIST *  idls, REFIID  riid, UINT *  inOut, void **  out  )

static

Definition at line 2592 of file ordinal.c.

{
    ok(0, "Didn't expect GetUIObjectOf\n");
    return E_NOTIMPL;
}

SF_ParseDisplayName()

static HRESULT WINAPI SF_ParseDisplayName ( IShellFolder *  iface, HWND  owner, LPBC  reserved, LPOLESTR  displayName, ULONG *  eaten, LPITEMIDLIST *  idl, ULONG *  attr  )

static

Definition at line 2538 of file ordinal.c.

{
    ok(0, "Didn't expect ParseDisplayName\n");
    return E_NOTIMPL;
}

SF_QueryInterface()

static HRESULT WINAPI SF_QueryInterface ( IShellFolder *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 2519 of file ordinal.c.

{
    /* SHIShellFolder_EnumObjects doesn't QI the object for IShellFolder */
    ok(!IsEqualGUID(&IID_IShellFolder, riid),
            "Unexpected QI for IShellFolder\n");
    return E_NOINTERFACE;
}

SF_Release()

static ULONG WINAPI SF_Release ( IShellFolder *  iface )

static

Definition at line 2533 of file ordinal.c.

{
    return 1;
}

SF_SetNameOf()

static HRESULT WINAPI SF_SetNameOf ( IShellFolder *  iface, HWND  hwnd, LPCITEMIDLIST  idl, LPCOLESTR  name, SHGDNF  flags, LPITEMIDLIST *  idlOut  )

static

Definition at line 2611 of file ordinal.c.

{
    ok(0, "Didn't expect SetNameOf\n");
    return E_NOTIMPL;
}

START_TEST()

START_TEST

(

ordinal

)

Definition at line 3122 of file ordinal.c.

{
    char **argv;
    int argc;
 
    hShlwapi = GetModuleHandleA("shlwapi.dll");
 
    init_pointers();
 
    argc = winetest_get_mainargs(&argv);
    if (argc >= 4)
    {
        DWORD procid;
        HANDLE hmem;
        sscanf(argv[2], "%d", &procid);
        sscanf(argv[3], "%p", &hmem);
        test_alloc_shared_remote(procid, hmem);
        return;
    }
 
    test_GetAcceptLanguagesA();
    test_SHSearchMapInt();
    test_alloc_shared(argc, argv);
    test_fdsa();
    test_GetShellSecurityDescriptor();
    test_SHPackDispParams();
    test_IConnectionPoint();
    test_SHPropertyBag_ReadLONG();
    test_SHSetWindowBits();
    test_SHFormatDateTimeA();
    test_SHFormatDateTimeW();
    test_SHGetObjectCompatFlags();
    test_IUnknown_QueryServiceExec();
    test_IUnknown_ProfferService();
    test_SHCreateWorkerWindowA();
    test_SHIShellFolder_EnumObjects();
    test_SHGetIniString();
    test_SHSetIniString();
    test_SHGetShellKey();
    test_SHSetParentHwnd();
    test_IUnknown_GetClassID();
    test_DllGetVersion();
}

strcmp_wa()

static int strcmp_wa ( LPCWSTR  strw, const char *  stra  )

static

Definition at line 101 of file ordinal.c.

{
    CHAR buf[512];
    WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
    return lstrcmpA(stra, buf);
}

Referenced by test_SHGetIniString().

test_alloc_shared()

static void test_alloc_shared ( int  argc, char **  argv  )

static

Definition at line 461 of file ordinal.c.

{
    char cmdline[MAX_PATH];
    PROCESS_INFORMATION pi;
    STARTUPINFOA si = { 0 };
    DWORD procid;
    HANDLE hmem, hmem2 = 0;
    struct shared_struct val, *p;
    BOOL ret;
 
    procid=GetCurrentProcessId();
    hmem=pSHAllocShared(NULL,10,procid);
    ok(hmem!=NULL,"SHAllocShared(NULL...) failed: %u\n", GetLastError());
    ret = pSHFreeShared(hmem, procid);
    ok( ret, "SHFreeShared failed: %u\n", GetLastError());
 
    val.value = 0x12345678;
    val.handle = 0;
    hmem = pSHAllocShared(&val, sizeof(val), procid);
    ok(hmem!=NULL,"SHAllocShared(NULL...) failed: %u\n", GetLastError());
 
    p=pSHLockShared(hmem,procid);
    ok(p!=NULL,"SHLockShared failed: %u\n", GetLastError());
    if (p!=NULL)
        ok(p->value == 0x12345678, "Wrong value in shared memory: %d instead of %d\n", p->value, 0x12345678);
    ret = pSHUnlockShared(p);
    ok( ret, "SHUnlockShared failed: %u\n", GetLastError());
 
    sprintf(cmdline, "%s %s %d %p", argv[0], argv[1], procid, hmem);
    ret = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
    ok(ret, "could not create child process error: %u\n", GetLastError());
    if (ret)
    {
        winetest_wait_child_process(pi.hProcess);
        CloseHandle(pi.hThread);
        CloseHandle(pi.hProcess);
 
        p = pSHLockShared(hmem, procid);
        ok(p != NULL,"SHLockShared failed: %u\n", GetLastError());
        if (p != NULL && p->value != 0x12345678)
        {
            ok(p->value == 0x12345679, "Wrong value in shared memory: %d instead of %d\n", p->value, 0x12345679);
            hmem2 = p->handle;
            ok(hmem2 != NULL, "Expected handle in shared memory\n");
        }
        ret = pSHUnlockShared(p);
        ok(ret, "SHUnlockShared failed: %u\n", GetLastError());
    }
 
    ret = pSHFreeShared(hmem, procid);
    ok( ret, "SHFreeShared failed: %u\n", GetLastError());
 
    if (hmem2)
    {
        p = pSHLockShared(hmem2, procid);
        ok(p != NULL,"SHLockShared failed: %u\n", GetLastError());
        if (p != NULL)
            ok(p->value == 0xDEADBEEF, "Wrong value in shared memory: %d instead of %d\n", p->value, 0xDEADBEEF);
        ret = pSHUnlockShared(p);
        ok(ret, "SHUnlockShared failed: %u\n", GetLastError());
 
        ret = pSHFreeShared(hmem2, procid);
        ok(ret, "SHFreeShared failed: %u\n", GetLastError());
    }
 
    SetLastError(0xdeadbeef);
    ret = pSHFreeShared(NULL, procid);
    ok(ret, "SHFreeShared failed: %u\n", GetLastError());
    ok(GetLastError() == 0xdeadbeef, "last error should not have changed, got %u\n", GetLastError());
}

Referenced by START_TEST().

test_alloc_shared_remote()

static void test_alloc_shared_remote ( DWORD  procid, HANDLE  hmem  )

static

Definition at line 532 of file ordinal.c.

{
    struct shared_struct val, *p;
    HANDLE hmem2;
    BOOL ret;
 
    /* test directly accessing shared memory of a remote process */
    p = pSHLockShared(hmem, procid);
    ok(p != NULL || broken(p == NULL) /* Windows 7/8 */, "SHLockShared failed: %u\n", GetLastError());
    if (p == NULL)
    {
        win_skip("Subprocess failed to modify shared memory, skipping test\n");
        return;
    }
 
    ok(p->value == 0x12345678, "Wrong value in shared memory: %d instead of %d\n", p->value, 0x12345678);
    p->value++;
 
    val.value = 0xDEADBEEF;
    val.handle = 0;
    p->handle = pSHAllocShared(&val, sizeof(val), procid);
    ok(p->handle != NULL, "SHAllocShared failed: %u\n", GetLastError());
 
    ret = pSHUnlockShared(p);
    ok(ret, "SHUnlockShared failed: %u\n", GetLastError());
 
    /* test SHMapHandle */
    SetLastError(0xdeadbeef);
    hmem2 = pSHMapHandle(NULL, procid, GetCurrentProcessId(), 0, 0);
    ok(hmem2 == NULL, "expected NULL, got new handle\n");
    ok(GetLastError() == 0xdeadbeef, "last error should not have changed, got %u\n", GetLastError());
 
    hmem2 = pSHMapHandle(hmem, procid, GetCurrentProcessId(), 0, 0);
 
    /* It seems like Windows Vista/2008 uses a different internal implementation
     * for shared memory, and calling SHMapHandle fails. */
    ok(hmem2 != NULL || broken(hmem2 == NULL),
       "SHMapHandle failed: %u\n", GetLastError());
    if (hmem2 == NULL)
    {
        win_skip("Subprocess failed to map shared memory, skipping test\n");
        return;
    }
 
    p = pSHLockShared(hmem2, GetCurrentProcessId());
    ok(p != NULL, "SHLockShared failed: %u\n", GetLastError());
 
    if (p != NULL)
        ok(p->value == 0x12345679, "Wrong value in shared memory: %d instead of %d\n", p->value, 0x12345679);
 
    ret = pSHUnlockShared(p);
    ok(ret, "SHUnlockShared failed: %u\n", GetLastError());
 
    ret = pSHFreeShared(hmem2, GetCurrentProcessId());
    ok(ret, "SHFreeShared failed: %u\n", GetLastError());
}

Referenced by START_TEST().

test_DllGetVersion()

static void test_DllGetVersion ( void  )

static

Definition at line 3114 of file ordinal.c.

{
    HRESULT hr;
 
    hr = pDllGetVersion(NULL);
    ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
}

Referenced by START_TEST().

test_fdsa()

static void test_fdsa ( void  )

static

Definition at line 589 of file ordinal.c.

{
    typedef struct
    {
        DWORD num_items;       /* Number of elements inserted */
        void *mem;             /* Ptr to array */
        DWORD blocks_alloced;  /* Number of elements allocated */
        BYTE inc;              /* Number of elements to grow by when we need to expand */
        BYTE block_size;       /* Size in bytes of an element */
        BYTE flags;            /* Flags */
    } FDSA_info;
 
    BOOL (WINAPI *pFDSA_Initialize)(DWORD block_size, DWORD inc, FDSA_info *info, void *mem,
                                    DWORD init_blocks);
    BOOL (WINAPI *pFDSA_Destroy)(FDSA_info *info);
    DWORD (WINAPI *pFDSA_InsertItem)(FDSA_info *info, DWORD where, const void *block);
    BOOL (WINAPI *pFDSA_DeleteItem)(FDSA_info *info, DWORD where);
 
    FDSA_info info;
    int block_size = 10, init_blocks = 4, inc = 2;
    DWORD ret;
    char *mem;
 
    pFDSA_Initialize = (void *)GetProcAddress(hShlwapi, (LPSTR)208);
    pFDSA_Destroy    = (void *)GetProcAddress(hShlwapi, (LPSTR)209);
    pFDSA_InsertItem = (void *)GetProcAddress(hShlwapi, (LPSTR)210);
    pFDSA_DeleteItem = (void *)GetProcAddress(hShlwapi, (LPSTR)211);
 
    mem = HeapAlloc(GetProcessHeap(), 0, block_size * init_blocks);
    memset(&info, 0, sizeof(info));
 
    ok(pFDSA_Initialize(block_size, inc, &info, mem, init_blocks), "FDSA_Initialize rets FALSE\n");
    ok(info.num_items == 0, "num_items = %d\n", info.num_items);
    ok(info.mem == mem, "mem = %p\n", info.mem);
    ok(info.blocks_alloced == init_blocks, "blocks_alloced = %d\n", info.blocks_alloced);
    ok(info.inc == inc, "inc = %d\n", info.inc);
    ok(info.block_size == block_size, "block_size = %d\n", info.block_size);
    ok(info.flags == 0, "flags = %d\n", info.flags);
 
    ret = pFDSA_InsertItem(&info, 1234, "1234567890");
    ok(ret == 0, "ret = %d\n", ret);
    ok(info.num_items == 1, "num_items = %d\n", info.num_items);
    ok(info.mem == mem, "mem = %p\n", info.mem);
    ok(info.blocks_alloced == init_blocks, "blocks_alloced = %d\n", info.blocks_alloced);
    ok(info.inc == inc, "inc = %d\n", info.inc);
    ok(info.block_size == block_size, "block_size = %d\n", info.block_size);
    ok(info.flags == 0, "flags = %d\n", info.flags);
 
    ret = pFDSA_InsertItem(&info, 1234, "abcdefghij");
    ok(ret == 1, "ret = %d\n", ret);
 
    ret = pFDSA_InsertItem(&info, 1, "klmnopqrst");
    ok(ret == 1, "ret = %d\n", ret);
 
    ret = pFDSA_InsertItem(&info, 0, "uvwxyzABCD");
    ok(ret == 0, "ret = %d\n", ret);
    ok(info.mem == mem, "mem = %p\n", info.mem);
    ok(info.flags == 0, "flags = %d\n", info.flags);
 
    /* This next InsertItem will cause shlwapi to allocate its own mem buffer */
    ret = pFDSA_InsertItem(&info, 0, "EFGHIJKLMN");
    ok(ret == 0, "ret = %d\n", ret);
    ok(info.mem != mem, "mem = %p\n", info.mem);
    ok(info.blocks_alloced == init_blocks + inc, "blocks_alloced = %d\n", info.blocks_alloced);
    ok(info.flags == 0x1, "flags = %d\n", info.flags);
 
    ok(!memcmp(info.mem, "EFGHIJKLMNuvwxyzABCD1234567890klmnopqrstabcdefghij", 50), "mem %s\n", (char*)info.mem);
 
    ok(pFDSA_DeleteItem(&info, 2), "rets FALSE\n");
    ok(info.mem != mem, "mem = %p\n", info.mem);
    ok(info.blocks_alloced == init_blocks + inc, "blocks_alloced = %d\n", info.blocks_alloced);
    ok(info.flags == 0x1, "flags = %d\n", info.flags);
 
    ok(!memcmp(info.mem, "EFGHIJKLMNuvwxyzABCDklmnopqrstabcdefghij", 40), "mem %s\n", (char*)info.mem);
 
    ok(pFDSA_DeleteItem(&info, 3), "rets FALSE\n");
    ok(info.mem != mem, "mem = %p\n", info.mem);
    ok(info.blocks_alloced == init_blocks + inc, "blocks_alloced = %d\n", info.blocks_alloced);
    ok(info.flags == 0x1, "flags = %d\n", info.flags);
 
    ok(!memcmp(info.mem, "EFGHIJKLMNuvwxyzABCDklmnopqrst", 30), "mem %s\n", (char*)info.mem);
 
    ok(!pFDSA_DeleteItem(&info, 4), "does not ret FALSE\n");
 
    /* As shlwapi has allocated memory internally, Destroy will ret FALSE */
    ok(!pFDSA_Destroy(&info), "FDSA_Destroy does not ret FALSE\n");
 
 
    /* When Initialize is called with inc = 0, set it to 1 */
    ok(pFDSA_Initialize(block_size, 0, &info, mem, init_blocks), "FDSA_Initialize rets FALSE\n");
    ok(info.inc == 1, "inc = %d\n", info.inc);
 
    /* This time, because shlwapi hasn't had to allocate memory
       internally, Destroy rets non-zero */
    ok(pFDSA_Destroy(&info), "FDSA_Destroy rets FALSE\n");
 
 
    HeapFree(GetProcessHeap(), 0, mem);
}

Referenced by START_TEST().

test_GetAcceptLanguagesA()

static void test_GetAcceptLanguagesA ( void  )

static

Definition at line 182 of file ordinal.c.

{
    static LPCSTR table[] = {"de,en-gb;q=0.7,en;q=0.3",
                             "de,en;q=0.3,en-gb;q=0.7", /* sorting is ignored */
                             "winetest",    /* content is ignored */
                             "de-de,de;q=0.5",
                             "de",
                             NULL};
 
    DWORD exactsize;
    char original[512];
    char language[32];
    char buffer[64];
    HKEY hroot = NULL;
    LONG res_query = ERROR_SUCCESS;
    LONG lres;
    HRESULT hr;
    DWORD maxlen = sizeof(buffer) - 2;
    DWORD len;
    LCID lcid;
    LPCSTR entry;
    INT i = 0;
 
    lcid = GetUserDefaultLCID();
 
    /* Get the original Value */
    lres = RegOpenKeyA(HKEY_CURRENT_USER, ie_international, &hroot);
    if (lres) {
        skip("RegOpenKey(%s) failed: %d\n", ie_international, lres);
        return;
    }
    len = sizeof(original);
    original[0] = 0;
    res_query = RegQueryValueExA(hroot, acceptlanguage, 0, NULL, (PBYTE)original, &len);
 
    RegDeleteValueA(hroot, acceptlanguage);
 
    /* Some windows versions use "lang-COUNTRY" as default */
    memset(language, 0, sizeof(language));
    len = GetLocaleInfoA(lcid, LOCALE_SISO639LANGNAME, language, sizeof(language));
 
    if (len) {
        lstrcatA(language, "-");
        memset(buffer, 0, sizeof(buffer));
        len = GetLocaleInfoA(lcid, LOCALE_SISO3166CTRYNAME, buffer, sizeof(buffer) - len - 1);
        lstrcatA(language, buffer);
    }
    else
    {
        /* LOCALE_SNAME has additional parts in some languages. Try only as last chance */
        memset(language, 0, sizeof(language));
        len = GetLocaleInfoA(lcid, LOCALE_SNAME, language, sizeof(language));
    }
 
    /* get the default value */
    len = maxlen;
    memset(buffer, '#', maxlen);
    buffer[maxlen] = 0;
    hr = pGetAcceptLanguagesA( buffer, &len);
 
    if (hr != S_OK) {
        win_skip("GetAcceptLanguagesA failed with 0x%x\n", hr);
        goto restore_original;
    }
 
    if (lstrcmpA(buffer, language)) {
        /* some windows versions use "lang" or "lang-country" as default */
        language[0] = 0;
        hr = LcidToRfc1766A(lcid, language, sizeof(language));
        ok(hr == S_OK, "LcidToRfc1766A returned 0x%x and %s\n", hr, language);
    }
 
    ok(!lstrcmpA(buffer, language),
        "have '%s' (searching for '%s')\n", language, buffer);
 
    if (lstrcmpA(buffer, language)) {
        win_skip("no more ideas, how to build the default language '%s'\n", buffer);
        goto restore_original;
    }
 
    trace("detected default: %s\n", language);
    while ((entry = table[i])) {
 
        exactsize = lstrlenA(entry);
 
        lres = RegSetValueExA(hroot, acceptlanguage, 0, REG_SZ, (const BYTE *) entry, exactsize + 1);
        ok(!lres, "got %d for RegSetValueExA: %s\n", lres, entry);
 
        /* len includes space for the terminating 0 before vista/w2k8 */
        len = exactsize + 2;
        memset(buffer, '#', maxlen);
        buffer[maxlen] = 0;
        hr = pGetAcceptLanguagesA( buffer, &len);
        ok(((hr == E_INVALIDARG) && (len == 0)) ||
            (SUCCEEDED(hr) &&
            ((len == exactsize) || (len == exactsize+1)) &&
            !lstrcmpA(buffer, entry)),
            "+2_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
 
        len = exactsize + 1;
        memset(buffer, '#', maxlen);
        buffer[maxlen] = 0;
        hr = pGetAcceptLanguagesA( buffer, &len);
        ok(((hr == E_INVALIDARG) && (len == 0)) ||
            (SUCCEEDED(hr) &&
            ((len == exactsize) || (len == exactsize+1)) &&
            !lstrcmpA(buffer, entry)),
            "+1_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
 
        len = exactsize;
        memset(buffer, '#', maxlen);
        buffer[maxlen] = 0;
        hr = pGetAcceptLanguagesA( buffer, &len);
 
        /* There is no space for the string in the registry.
           When the buffer is large enough, the default language is returned
 
           When the buffer is too small for that fallback, win7_32 and w2k8_64
           fail with E_NOT_SUFFICIENT_BUFFER, win8 fails with HRESULT_FROM_WIN32(ERROR_MORE_DATA),
           other versions succeed and return a partial result while older os succeed
           and overflow the buffer */
 
        ok(((hr == E_INVALIDARG) && (len == 0)) ||
            (((hr == S_OK) && !lstrcmpA(buffer, language)  && (len == lstrlenA(language))) ||
            ((hr == S_OK) && !memcmp(buffer, language, len)) ||
            ((hr == E_NOT_SUFFICIENT_BUFFER) && !len) ||
            ((hr == __HRESULT_FROM_WIN32(ERROR_MORE_DATA)) && len == exactsize)),
            "==_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
 
        if (exactsize > 1) {
            len = exactsize - 1;
            memset(buffer, '#', maxlen);
            buffer[maxlen] = 0;
            hr = pGetAcceptLanguagesA( buffer, &len);
            ok(((hr == E_INVALIDARG) && (len == 0)) ||
                (((hr == S_OK) && !lstrcmpA(buffer, language)  && (len == lstrlenA(language))) ||
                ((hr == S_OK) && !memcmp(buffer, language, len)) ||
                ((hr == E_NOT_SUFFICIENT_BUFFER) && !len) ||
                ((hr == __HRESULT_FROM_WIN32(ERROR_MORE_DATA)) && len == exactsize - 1)),
                "-1_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
        }
 
        len = 1;
        memset(buffer, '#', maxlen);
        buffer[maxlen] = 0;
        hr = pGetAcceptLanguagesA( buffer, &len);
        ok(((hr == E_INVALIDARG) && (len == 0)) ||
            (((hr == S_OK) && !lstrcmpA(buffer, language)  && (len == lstrlenA(language))) ||
            ((hr == S_OK) && !memcmp(buffer, language, len)) ||
            ((hr == E_NOT_SUFFICIENT_BUFFER) && !len) ||
            ((hr == __HRESULT_FROM_WIN32(ERROR_MORE_DATA)) && len == 1)),
            "=1_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
 
        len = maxlen;
        hr = pGetAcceptLanguagesA( NULL, &len);
 
        /* w2k3 and below: E_FAIL and untouched len,
           since w2k8: S_OK and needed size (excluding 0), win8 S_OK and size including 0. */
        ok( ((hr == S_OK) && ((len == exactsize) || (len == exactsize + 1))) ||
            ((hr == E_FAIL) && (len == maxlen)),
            "NULL,max #%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
 
        i++;
    }
 
    /* without a value in the registry, a default language is returned */
    RegDeleteValueA(hroot, acceptlanguage);
 
    len = maxlen;
    memset(buffer, '#', maxlen);
    buffer[maxlen] = 0;
    hr = pGetAcceptLanguagesA( buffer, &len);
    ok( ((hr == S_OK) && (len == lstrlenA(language))),
        "max: got 0x%x with %d and %s (expected S_OK with %d and '%s'\n",
        hr, len, buffer, lstrlenA(language), language);
 
    len = 2;
    memset(buffer, '#', maxlen);
    buffer[maxlen] = 0;
    hr = pGetAcceptLanguagesA( buffer, &len);
    ok( (((hr == S_OK) || (hr == E_INVALIDARG)) && !memcmp(buffer, language, len)) ||
        ((hr == E_NOT_SUFFICIENT_BUFFER) && !len) ||
        ((hr == __HRESULT_FROM_WIN32(ERROR_CANNOT_COPY)) && !len),
        "=2: got 0x%x with %d and %s\n", hr, len, buffer);
 
    len = 1;
    memset(buffer, '#', maxlen);
    buffer[maxlen] = 0;
    hr = pGetAcceptLanguagesA( buffer, &len);
    /* When the buffer is too small, win7_32 and w2k8_64 and above fail with
       E_NOT_SUFFICIENT_BUFFER, win8 ERROR_CANNOT_COPY,
       other versions succeed and return a partial 0 terminated result while other versions
       fail with E_INVALIDARG and return a partial unterminated result */
    ok( (((hr == S_OK) || (hr == E_INVALIDARG)) && !memcmp(buffer, language, len)) ||
        ((hr == E_NOT_SUFFICIENT_BUFFER) && !len) ||
        ((hr == __HRESULT_FROM_WIN32(ERROR_CANNOT_COPY)) && !len),
        "=1: got 0x%x with %d and %s\n", hr, len, buffer);
 
    len = 0;
    memset(buffer, '#', maxlen);
    buffer[maxlen] = 0;
    hr = pGetAcceptLanguagesA( buffer, &len);
    /* w2k3 and below: E_FAIL, since w2k8: E_INVALIDARG, win8 ERROR_CANNOT_COPY */
    ok((hr == E_FAIL) || (hr == E_INVALIDARG) || (hr == __HRESULT_FROM_WIN32(ERROR_CANNOT_COPY)),
        "got 0x%x\n", hr);
 
    memset(buffer, '#', maxlen);
    buffer[maxlen] = 0;
    hr = pGetAcceptLanguagesA( buffer, NULL);
    /* w2k3 and below: E_FAIL, since w2k8: E_INVALIDARG */
    ok((hr == E_FAIL) || (hr == E_INVALIDARG),
        "got 0x%x (expected E_FAIL or E_INVALIDARG)\n", hr);
 
 
    hr = pGetAcceptLanguagesA( NULL, NULL);
    /* w2k3 and below: E_FAIL, since w2k8: E_INVALIDARG */
    ok((hr == E_FAIL) || (hr == E_INVALIDARG),
        "got 0x%x (expected E_FAIL or E_INVALIDARG)\n", hr);
 
restore_original:
    if (!res_query) {
        len = lstrlenA(original);
        lres = RegSetValueExA(hroot, acceptlanguage, 0, REG_SZ, (const BYTE *) original, len ? len + 1: 0);
        ok(!lres, "RegSetValueEx(%s) failed: %d\n", original, lres);
    }
    else
    {
        RegDeleteValueA(hroot, acceptlanguage);
    }
    RegCloseKey(hroot);
}

Referenced by START_TEST().

test_GetShellSecurityDescriptor()

static void test_GetShellSecurityDescriptor ( void  )

static

Definition at line 689 of file ordinal.c.

{
    static const SHELL_USER_PERMISSION supCurrentUserFull = {
        { {SECURITY_NULL_SID_AUTHORITY}, 0, 0 },
        ACCESS_ALLOWED_ACE_TYPE, FALSE,
        GENERIC_ALL, 0, 0 };
#define MY_INHERITANCE 0xBE /* invalid value to proof behavior */
    static const SHELL_USER_PERMISSION supEveryoneDenied = {
        { {SECURITY_WORLD_SID_AUTHORITY}, SECURITY_WORLD_RID, 0 },
        ACCESS_DENIED_ACE_TYPE, TRUE,
        GENERIC_WRITE, MY_INHERITANCE | 0xDEADBA00, GENERIC_READ };
    const SHELL_USER_PERMISSION* rgsup[2] = {
        &supCurrentUserFull, &supEveryoneDenied,
    };
    SECURITY_DESCRIPTOR* psd;
 
    if(!pGetShellSecurityDescriptor) /* vista and later */
    {
        win_skip("GetShellSecurityDescriptor not available\n");
        return;
    }
 
    psd = pGetShellSecurityDescriptor(NULL, 2);
    ok(psd==NULL, "GetShellSecurityDescriptor should fail\n");
    psd = pGetShellSecurityDescriptor(rgsup, 0);
    ok(psd==NULL, "GetShellSecurityDescriptor should fail, got %p\n", psd);
 
    SetLastError(0xdeadbeef);
    psd = pGetShellSecurityDescriptor(rgsup, 2);
    ok(psd!=NULL, "GetShellSecurityDescriptor failed\n");
    if (psd!=NULL)
    {
        BOOL bHasDacl = FALSE, bDefaulted, ret;
        PACL pAcl;
        DWORD dwRev;
        SECURITY_DESCRIPTOR_CONTROL control;
 
        ok(IsValidSecurityDescriptor(psd), "returned value is not valid SD\n");
 
        ret = GetSecurityDescriptorControl(psd, &control, &dwRev);
        ok(ret, "GetSecurityDescriptorControl failed with error %u\n", GetLastError());
        ok(0 == (control & SE_SELF_RELATIVE), "SD should be absolute\n");
 
        ret = GetSecurityDescriptorDacl(psd, &bHasDacl, &pAcl, &bDefaulted);
        ok(ret, "GetSecurityDescriptorDacl failed with error %u\n", GetLastError());
 
        ok(bHasDacl, "SD has no DACL\n");
        if (bHasDacl)
        {
            ok(!bDefaulted, "DACL should not be defaulted\n");
 
            ok(pAcl != NULL, "NULL DACL!\n");
            if (pAcl != NULL)
            {
                ACL_SIZE_INFORMATION asiSize;
 
                ok(IsValidAcl(pAcl), "DACL is not valid\n");
 
                ret = GetAclInformation(pAcl, &asiSize, sizeof(asiSize), AclSizeInformation);
                ok(ret, "GetAclInformation failed with error %u\n", GetLastError());
 
                ok(asiSize.AceCount == 3, "Incorrect number of ACEs: %d entries\n", asiSize.AceCount);
                if (asiSize.AceCount == 3)
                {
                    ACCESS_ALLOWED_ACE *paaa; /* will use for DENIED too */
 
                    ret = GetAce(pAcl, 0, (LPVOID*)&paaa);
                    ok(ret, "GetAce failed with error %u\n", GetLastError());
                    ok(paaa->Header.AceType == ACCESS_ALLOWED_ACE_TYPE, 
                            "Invalid ACE type %d\n", paaa->Header.AceType); 
                    ok(paaa->Header.AceFlags == 0, "Invalid ACE flags %x\n", paaa->Header.AceFlags);
                    ok(paaa->Mask == GENERIC_ALL, "Invalid ACE mask %x\n", paaa->Mask);
 
                    ret = GetAce(pAcl, 1, (LPVOID*)&paaa);
                    ok(ret, "GetAce failed with error %u\n", GetLastError());
                    ok(paaa->Header.AceType == ACCESS_DENIED_ACE_TYPE, 
                            "Invalid ACE type %d\n", paaa->Header.AceType); 
                    /* first one of two ACEs generated from inheritable entry - without inheritance */
                    ok(paaa->Header.AceFlags == 0, "Invalid ACE flags %x\n", paaa->Header.AceFlags);
                    ok(paaa->Mask == GENERIC_WRITE, "Invalid ACE mask %x\n", paaa->Mask);
 
                    ret = GetAce(pAcl, 2, (LPVOID*)&paaa);
                    ok(ret, "GetAce failed with error %u\n", GetLastError());
                    ok(paaa->Header.AceType == ACCESS_DENIED_ACE_TYPE, 
                            "Invalid ACE type %d\n", paaa->Header.AceType); 
                    /* second ACE - with inheritance */
                    ok(paaa->Header.AceFlags == MY_INHERITANCE,
                            "Invalid ACE flags %x\n", paaa->Header.AceFlags);
                    ok(paaa->Mask == GENERIC_READ, "Invalid ACE mask %x\n", paaa->Mask);
                }
            }
        }
 
        LocalFree(psd);
    }
}

Referenced by START_TEST().

test_IConnectionPoint()

static void test_IConnectionPoint ( void  )

static

Definition at line 1451 of file ordinal.c.

{
    HRESULT rc;
    ULONG ref;
    IConnectionPoint *point;
    Contain *container;
    Disp *dispatch;
    DWORD cookie = 0xffffffff;
    DISPPARAMS params;
    VARIANT vars[10];
 
    container = HeapAlloc(GetProcessHeap(),0,sizeof(Contain));
    container->IConnectionPointContainer_iface.lpVtbl = &contain_vtbl;
    container->refCount = 1;
    container->ptCount = 0;
    container->pt = NULL;
 
    dispatch = HeapAlloc(GetProcessHeap(),0,sizeof(Disp));
    dispatch->IDispatch_iface.lpVtbl = &disp_vtbl;
    dispatch->refCount = 1;
 
    rc = pConnectToConnectionPoint((IUnknown*)dispatch, &IID_NULL, TRUE, (IUnknown*)container, &cookie, &point);
    ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc);
    ok(point != NULL, "returned ConnectionPoint is NULL\n");
    ok(cookie != 0xffffffff, "invalid cookie returned\n");
 
    rc = pIConnectionPoint_SimpleInvoke(point,0xa0,NULL);
    ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc);
 
    memset(&params, 0xc0, sizeof(params));
    memset(vars, 0xc0, sizeof(vars));
    rc = pSHPackDispParams(&params, vars, 2, VT_I4, 0xdeadbeef, VT_BSTR, 0xdeadcafe);
    ok(rc == S_OK, "SHPackDispParams failed: %08x\n", rc);
 
    rc = pIConnectionPoint_SimpleInvoke(point,0xa1,&params);
    ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc);
 
    rc = pConnectToConnectionPoint(NULL, &IID_NULL, FALSE, (IUnknown*)container, &cookie, NULL);
    ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc);
 
/* MSDN says this should be required but it crashs on XP
    IUnknown_Release(point);
*/
    ref = IUnknown_Release((IUnknown*)container);
    ok(ref == 0, "leftover IConnectionPointContainer reference %i\n",ref);
    ref = IUnknown_Release((IUnknown*)dispatch);
    ok(ref == 0, "leftover IDispatch reference %i\n",ref);
}

Referenced by START_TEST().

test_IUnknown_GetClassID()

static void test_IUnknown_GetClassID ( void  )

static

Definition at line 3082 of file ordinal.c.

{
    CLSID clsid, clsid2, clsid3;
    HRESULT hr;
 
    if (0) /* crashes on native systems */
        hr = pIUnknown_GetClassID(NULL, NULL);
 
    memset(&clsid, 0xcc, sizeof(clsid));
    memset(&clsid3, 0xcc, sizeof(clsid3));
    hr = pIUnknown_GetClassID(NULL, &clsid);
    ok(hr == E_FAIL, "got 0x%08x\n", hr);
    ok(IsEqualCLSID(&clsid, &CLSID_NULL) || broken(IsEqualCLSID(&clsid, &clsid3)) /* win2k, winxp, win2k3 */,
        "got wrong clsid %s\n", wine_dbgstr_guid(&clsid));
 
    memset(&clsid, 0xcc, sizeof(clsid));
    memset(&clsid2, 0xab, sizeof(clsid2));
    hr = pIUnknown_GetClassID((IUnknown*)&testpersist, &clsid);
    ok(hr == 0x8fff2222, "got 0x%08x\n", hr);
    ok(IsEqualCLSID(&clsid, &clsid2) || broken(IsEqualCLSID(&clsid, &clsid3)) /* win2k3 */,
        "got wrong clsid %s\n", wine_dbgstr_guid(&clsid));
 
    /* IPersistFolder is also supported */
    memset(&clsid, 0xcc, sizeof(clsid));
    memset(&clsid2, 0xab, sizeof(clsid2));
    memset(&clsid3, 0xcc, sizeof(clsid3));
    hr = pIUnknown_GetClassID((IUnknown*)&testpersist2, &clsid);
    ok(hr == 0x8fff2222, "got 0x%08x\n", hr);
    ok(IsEqualCLSID(&clsid, &clsid2) || broken(IsEqualCLSID(&clsid, &clsid3)) /* win2k3 */,
        "got wrong clsid %s\n", wine_dbgstr_guid(&clsid));
}

Referenced by START_TEST().

test_IUnknown_ProfferService()

static void test_IUnknown_ProfferService ( void  )

static

Definition at line 2403 of file ordinal.c.

{
    IServiceProvider *provider;
    IProfferService *proff;
    static const GUID dummy_serviceid = { 0xdeadbeef };
    call_trace_t trace_expected;
    HRESULT hr;
    DWORD cookie;
 
    provider = IServiceProviderImpl_Construct();
    proff = IProfferServiceImpl_Construct();
 
    /* null source pointer */
    hr = pIUnknown_ProfferService(NULL, &dummy_serviceid, 0, 0);
    ok(hr == E_FAIL ||
       hr == E_NOTIMPL, /* win 8 */
       "got 0x%08x\n", hr);
 
    /* expected trace:
       IUnknown_ProfferService( ptr1, serviceid, arg1, arg2);
         -> IUnknown_QueryInterface( ptr1, &IID_IServiceProvider, &provider );
         -> IServiceProvider_QueryService( provider, &IID_IProfferService, &IID_IProfferService, &proffer );
 
         if (service pointer not null):
             -> IProfferService_ProfferService( proffer, serviceid, arg1, arg2 );
         else
             -> IProfferService_RevokeService( proffer, *arg2 );
    */
    init_call_trace(&trace_expected);
 
    add_call(&trace_expected, 1, proff, &IID_IServiceProvider, 0, 0, 0);
    add_call(&trace_expected, 2, &IID_IProfferService, &IID_IProfferService, 0, 0, 0);
    add_call(&trace_expected, 3, &dummy_serviceid, provider, &cookie, 0, 0);
 
    init_call_trace(&trace_got);
    cookie = 0;
    hr = pIUnknown_ProfferService((IUnknown*)proff, &dummy_serviceid, provider, &cookie);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(cookie == 0xdeadbeef, "got %x\n", cookie);
 
    ok_trace(&trace_expected, &trace_got);
    free_call_trace(&trace_got);
    free_call_trace(&trace_expected);
 
    /* same with ::Revoke path */
    init_call_trace(&trace_expected);
 
    add_call(&trace_expected, 1, proff, &IID_IServiceProvider, 0, 0, 0);
    add_call(&trace_expected, 2, &IID_IProfferService, &IID_IProfferService, 0, 0, 0);
    add_call(&trace_expected, 4, (void*)(DWORD_PTR)cookie, 0, 0, 0, 0);
 
    init_call_trace(&trace_got);
    ok(cookie != 0, "got %x\n", cookie);
    hr = pIUnknown_ProfferService((IUnknown*)proff, &dummy_serviceid, 0, &cookie);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(cookie == 0, "got %x\n", cookie);
    ok_trace(&trace_expected, &trace_got);
    free_call_trace(&trace_got);
    free_call_trace(&trace_expected);
 
    IServiceProvider_Release(provider);
    IProfferService_Release(proff);
}

Referenced by START_TEST().

test_IUnknown_QueryServiceExec()

static void test_IUnknown_QueryServiceExec ( void  )

static

Definition at line 2295 of file ordinal.c.

{
    IServiceProvider *provider;
    static const GUID dummy_serviceid = { 0xdeadbeef };
    static const GUID dummy_groupid = { 0xbeefbeef };
    call_trace_t trace_expected;
    HRESULT hr;
 
    provider = IServiceProviderImpl_Construct();
 
    /* null source pointer */
    hr = pIUnknown_QueryServiceExec(NULL, &dummy_serviceid, &dummy_groupid, 0, 0, 0, 0);
    ok(hr == E_FAIL ||
       hr == E_NOTIMPL, /* win 8 */
       "got 0x%08x\n", hr);
 
    /* expected trace:
       IUnknown_QueryServiceExec( ptr1, serviceid, groupid, arg1, arg2, arg3, arg4);
         -> IUnknown_QueryInterface( ptr1, &IID_IServiceProvider, &prov );
         -> IServiceProvider_QueryService( prov, serviceid, &IID_IOleCommandTarget, &obj );
         -> IOleCommandTarget_Exec( obj, groupid, arg1, arg2, arg3, arg4 );
    */
    init_call_trace(&trace_expected);
 
    add_call(&trace_expected, 1, provider, &IID_IServiceProvider, 0, 0, 0);
    add_call(&trace_expected, 2, provider, &dummy_serviceid, &IID_IOleCommandTarget, 0, 0);
    add_call(&trace_expected, 3, &dummy_groupid, (void*)0x1, (void*)0x2, (void*)0x3, (void*)0x4);
 
    init_call_trace(&trace_got);
    hr = pIUnknown_QueryServiceExec((IUnknown*)provider, &dummy_serviceid, &dummy_groupid, 0x1, 0x2, (void*)0x3, (void*)0x4);
    ok(hr == S_OK, "got 0x%08x\n", hr);
 
    ok_trace(&trace_expected, &trace_got);
 
    free_call_trace(&trace_expected);
    free_call_trace(&trace_got);
 
    IServiceProvider_Release(provider);
}

Referenced by START_TEST().

test_SHCreateWorkerWindowA()

static void test_SHCreateWorkerWindowA ( void  )

static

Definition at line 2467 of file ordinal.c.

{
    WNDCLASSA cliA;
    char classA[20];
    HWND hwnd;
    LONG_PTR ret;
    BOOL res;
 
    hwnd = pSHCreateWorkerWindowA(0, NULL, 0, 0, 0, 0);
    ok(hwnd != 0, "expected window\n");
 
    GetClassNameA(hwnd, classA, 20);
    ok(lstrcmpA(classA, "WorkerA") == 0, "expected WorkerA class, got %s\n", classA);
 
    ret = GetWindowLongPtrA(hwnd, 0);
    ok(ret == 0, "got %ld\n", ret);
 
    /* class info */
    memset(&cliA, 0, sizeof(cliA));
    res = GetClassInfoA(GetModuleHandleA("shlwapi.dll"), "WorkerA", &cliA);
    ok(res, "failed to get class info\n");
    ok(cliA.style == 0, "got 0x%08x\n", cliA.style);
    ok(cliA.cbClsExtra == 0, "got %d\n", cliA.cbClsExtra);
    ok(cliA.cbWndExtra == sizeof(LONG_PTR), "got %d\n", cliA.cbWndExtra);
    ok(cliA.lpszMenuName == 0, "got %s\n", cliA.lpszMenuName);
 
    DestroyWindow(hwnd);
 
    /* set extra bytes */
    hwnd = pSHCreateWorkerWindowA(0, NULL, 0, 0, 0, 0xdeadbeef);
    ok(hwnd != 0, "expected window\n");
 
    GetClassNameA(hwnd, classA, 20);
    ok(lstrcmpA(classA, "WorkerA") == 0, "expected WorkerA class, got %s\n", classA);
 
    ret = GetWindowLongPtrA(hwnd, 0);
    ok(ret == 0xdeadbeef, "got %ld\n", ret);
 
    /* test exstyle */
    ret = GetWindowLongA(hwnd, GWL_EXSTYLE);
    ok(ret == WS_EX_WINDOWEDGE ||
       ret == (WS_EX_WINDOWEDGE|WS_EX_LAYOUTRTL) /* systems with RTL locale */, "0x%08lx\n", ret);
 
    DestroyWindow(hwnd);
 
    hwnd = pSHCreateWorkerWindowA(0, NULL, WS_EX_TOOLWINDOW, 0, 0, 0);
    ret = GetWindowLongA(hwnd, GWL_EXSTYLE);
    ok(ret == (WS_EX_WINDOWEDGE|WS_EX_TOOLWINDOW) ||
       ret == (WS_EX_WINDOWEDGE|WS_EX_TOOLWINDOW|WS_EX_LAYOUTRTL) /* systems with RTL locale */, "0x%08lx\n", ret);
    DestroyWindow(hwnd);
}

Referenced by START_TEST().

test_SHFormatDateTimeA()

static void test_SHFormatDateTimeA ( void  )

static

Definition at line 1677 of file ordinal.c.

{
    FILETIME UNALIGNED filetime;
    CHAR buff[100], buff2[100], buff3[100];
    SYSTEMTIME st;
    DWORD flags;
    INT ret;
 
if (0)
{
    /* crashes on native */
    pSHFormatDateTimeA(NULL, NULL, NULL, 0);
}
 
    GetLocalTime(&st);
    SystemTimeToFileTime(&st, &filetime);
    /* SHFormatDateTime expects input as utc */
    LocalFileTimeToFileTime(&filetime, &filetime);
 
    /* no way to get required buffer length here */
    SetLastError(0xdeadbeef);
    ret = pSHFormatDateTimeA(&filetime, NULL, NULL, 0);
    ok(ret == 0, "got %d\n", ret);
    ok(GetLastError() == 0xdeadbeef || broken(GetLastError() == ERROR_SUCCESS /* Win7 */),
        "expected 0xdeadbeef, got %d\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    buff[0] = 'a'; buff[1] = 0;
    ret = pSHFormatDateTimeA(&filetime, NULL, buff, 0);
    ok(ret == 0, "got %d\n", ret);
    ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
    ok(buff[0] == 'a', "expected same string, got %s\n", buff);
 
    /* flags needs to have FDTF_NOAUTOREADINGORDER for these tests to succeed on Vista+ */
 
    /* all combinations documented as invalid succeeded */
    flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTTIME | FDTF_LONGTIME;
    SetLastError(0xdeadbeef);
    ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
    ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
    ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
 
    flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTDATE | FDTF_LONGDATE;
    SetLastError(0xdeadbeef);
    ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
    ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
    ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
 
    flags =  FDTF_SHORTDATE | FDTF_LTRDATE | FDTF_RTLDATE;
    SetLastError(0xdeadbeef);
    ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
    ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
    ok(GetLastError() == 0xdeadbeef,
        "expected 0xdeadbeef, got %d\n", GetLastError());
 
    /* now check returned strings */
    flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTTIME;
    ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
    ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
    ret = GetTimeFormatA(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff2, sizeof(buff2));
    ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
    ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
 
    flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGTIME;
    ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
    ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
    ret = GetTimeFormatA(LOCALE_USER_DEFAULT, 0, &st, NULL, buff2, sizeof(buff2));
    ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
    ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
 
    /* both time flags */
    flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGTIME | FDTF_SHORTTIME;
    ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
    ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
    ret = GetTimeFormatA(LOCALE_USER_DEFAULT, 0, &st, NULL, buff2, sizeof(buff2));
    ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
    ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
 
    flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTDATE;
    ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
    ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
    ret = GetDateFormatA(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, sizeof(buff2));
    ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
    ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
 
    flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGDATE;
    ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
    ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
    ret = GetDateFormatA(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2));
    ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
    ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
 
    /* both date flags */
    flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGDATE | FDTF_SHORTDATE;
    ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
    ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
    ret = GetDateFormatA(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2));
    ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
    ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
 
    /* various combinations of date/time flags */
    flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGDATE | FDTF_SHORTTIME;
    ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
    ok(ret == lstrlenA(buff)+1, "got %d, length %d\n", ret, lstrlenA(buff)+1);
    ret = GetTimeFormatA(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff3, sizeof(buff3));
    ok(ret == lstrlenA(buff3)+1, "got %d\n", ret);
    ok(lstrcmpA(buff3, buff + lstrlenA(buff) - lstrlenA(buff3)) == 0,
       "expected (%s), got (%s) for time part\n",
       buff3, buff + lstrlenA(buff) - lstrlenA(buff3));
    ret = GetDateFormatA(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2));
    ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
    buff[lstrlenA(buff2)] = '\0';
    ok(lstrcmpA(buff2, buff) == 0, "expected (%s) got (%s) for date part\n",
       buff2, buff);
 
    flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGDATE | FDTF_LONGTIME;
    ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
    ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
    ret = GetTimeFormatA(LOCALE_USER_DEFAULT, 0, &st, NULL, buff3, sizeof(buff3));
    ok(ret == lstrlenA(buff3)+1, "got %d\n", ret);
    ok(lstrcmpA(buff3, buff + lstrlenA(buff) - lstrlenA(buff3)) == 0,
       "expected (%s), got (%s) for time part\n",
       buff3, buff + lstrlenA(buff) - lstrlenA(buff3));
    ret = GetDateFormatA(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2));
    ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
    buff[lstrlenA(buff2)] = '\0';
    ok(lstrcmpA(buff2, buff) == 0, "expected (%s) got (%s) for date part\n",
       buff2, buff);
 
    flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTDATE | FDTF_SHORTTIME;
    ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
    ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
    ret = GetDateFormatA(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, sizeof(buff2));
    ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
    strcat(buff2, " ");
    ret = GetTimeFormatA(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff3, sizeof(buff3));
    ok(ret == lstrlenA(buff3)+1, "got %d\n", ret);
    strcat(buff2, buff3);
    ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
 
    flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTDATE | FDTF_LONGTIME;
    ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
    ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
    ret = GetDateFormatA(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, sizeof(buff2));
    ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
    strcat(buff2, " ");
    ret = GetTimeFormatA(LOCALE_USER_DEFAULT, 0, &st, NULL, buff3, sizeof(buff3));
    ok(ret == lstrlenA(buff3)+1, "got %d\n", ret);
    strcat(buff2, buff3);
    ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
}

Referenced by START_TEST().

test_SHFormatDateTimeW()

static void test_SHFormatDateTimeW ( void  )

static

Definition at line 1829 of file ordinal.c.

{
    FILETIME UNALIGNED filetime;
    WCHAR buff[100], buff2[100], buff3[100], *p1, *p2;
    SYSTEMTIME st;
    DWORD flags;
    INT ret;
    static const WCHAR spaceW[] = {' ',0};
#define UNICODE_LTR_MARK 0x200e
#define UNICODE_RTL_MARK 0x200f
 
if (0)
{
    /* crashes on native */
    pSHFormatDateTimeW(NULL, NULL, NULL, 0);
}
 
    GetLocalTime(&st);
    SystemTimeToFileTime(&st, &filetime);
    /* SHFormatDateTime expects input as utc */
    LocalFileTimeToFileTime(&filetime, &filetime);
 
    /* no way to get required buffer length here */
    SetLastError(0xdeadbeef);
    ret = pSHFormatDateTimeW(&filetime, NULL, NULL, 0);
    ok(ret == 0, "expected 0, got %d\n", ret);
    ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    buff[0] = 'a'; buff[1] = 0;
    ret = pSHFormatDateTimeW(&filetime, NULL, buff, 0);
    ok(ret == 0, "expected 0, got %d\n", ret);
    ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
    ok(buff[0] == 'a', "expected same string\n");
 
    /* all combinations documented as invalid succeeded */
    flags = FDTF_SHORTTIME | FDTF_LONGTIME;
    SetLastError(0xdeadbeef);
    ret = pSHFormatDateTimeW(&filetime, &flags, buff, ARRAY_SIZE(buff));
    ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
       "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
    ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
 
    flags = FDTF_SHORTDATE | FDTF_LONGDATE;
    SetLastError(0xdeadbeef);
    ret = pSHFormatDateTimeW(&filetime, &flags, buff, ARRAY_SIZE(buff));
    ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
       "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
    ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
 
    flags = FDTF_SHORTDATE | FDTF_LTRDATE | FDTF_RTLDATE;
    SetLastError(0xdeadbeef);
    buff[0] = 0; /* NT4 doesn't clear the buffer on failure */
    ret = pSHFormatDateTimeW(&filetime, &flags, buff, ARRAY_SIZE(buff));
    ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
       "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
    ok(GetLastError() == 0xdeadbeef,
        "expected 0xdeadbeef, got %d\n", GetLastError());
 
    /* now check returned strings */
    flags = FDTF_SHORTTIME;
    ret = pSHFormatDateTimeW(&filetime, &flags, buff, ARRAY_SIZE(buff));
    ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
       "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
    SetLastError(0xdeadbeef);
    ret = GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff2, ARRAY_SIZE(buff2));
    ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
    ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
 
    flags = FDTF_LONGTIME;
    ret = pSHFormatDateTimeW(&filetime, &flags, buff, ARRAY_SIZE(buff));
    ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
       "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
    ret = GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, buff2, ARRAY_SIZE(buff2));
    ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
    ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
 
    /* both time flags */
    flags = FDTF_LONGTIME | FDTF_SHORTTIME;
    ret = pSHFormatDateTimeW(&filetime, &flags, buff, ARRAY_SIZE(buff));
    ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
       "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
    ret = GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, buff2, ARRAY_SIZE(buff2));
    ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
    ok(lstrcmpW(buff, buff2) == 0, "expected equal string\n");
 
    flags = FDTF_SHORTDATE;
    ret = pSHFormatDateTimeW(&filetime, &flags, buff, ARRAY_SIZE(buff));
    ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
       "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
    ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, ARRAY_SIZE(buff2));
    ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
    ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
 
    flags = FDTF_LONGDATE;
    ret = pSHFormatDateTimeW(&filetime, &flags, buff, ARRAY_SIZE(buff));
    ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
       "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
    ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, ARRAY_SIZE(buff2));
    ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
    ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
 
    /* both date flags */
    flags = FDTF_LONGDATE | FDTF_SHORTDATE;
    ret = pSHFormatDateTimeW(&filetime, &flags, buff, ARRAY_SIZE(buff));
    ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
       "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
    ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, ARRAY_SIZE(buff2));
    ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
    ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
 
    /* various combinations of date/time flags */
    flags = FDTF_LONGDATE | FDTF_SHORTTIME;
    ret = pSHFormatDateTimeW(&filetime, &flags, buff, ARRAY_SIZE(buff));
    ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
       "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
    ret = GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff3, ARRAY_SIZE(buff3));
    ok(ret == lstrlenW(buff3)+1, "expected %d, got %d\n", lstrlenW(buff3)+1, ret);
    ok(lstrcmpW(buff3, buff + lstrlenW(buff) - lstrlenW(buff3)) == 0,
       "expected (%s), got (%s) for time part\n",
       wine_dbgstr_w(buff3), wine_dbgstr_w(buff + lstrlenW(buff) - lstrlenW(buff3)));
    ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, ARRAY_SIZE(buff2));
    ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
    p1 = buff;
    p2 = buff2;
    while (*p2 != '\0')
    {
        while (*p1 == UNICODE_LTR_MARK || *p1 == UNICODE_RTL_MARK)
            p1++;
        while (*p2 == UNICODE_LTR_MARK || *p2 == UNICODE_RTL_MARK)
            p2++;
        p1++;
        p2++;
    }
    *p1 = '\0';
    ok(lstrcmpW(buff2, buff) == 0, "expected (%s) got (%s) for date part\n",
       wine_dbgstr_w(buff2), wine_dbgstr_w(buff));
 
    flags = FDTF_LONGDATE | FDTF_LONGTIME;
    ret = pSHFormatDateTimeW(&filetime, &flags, buff, ARRAY_SIZE(buff));
    ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
       "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
    ret = GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, buff3, ARRAY_SIZE(buff3));
    ok(ret == lstrlenW(buff3)+1, "expected %d, got %d\n", lstrlenW(buff3)+1, ret);
    ok(lstrcmpW(buff3, buff + lstrlenW(buff) - lstrlenW(buff3)) == 0,
       "expected (%s), got (%s) for time part\n",
       wine_dbgstr_w(buff3), wine_dbgstr_w(buff + lstrlenW(buff) - lstrlenW(buff3)));
    ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, ARRAY_SIZE(buff2));
    ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
    p1 = buff;
    p2 = buff2;
    while (*p2 != '\0')
    {
        while (*p1 == UNICODE_LTR_MARK || *p1 == UNICODE_RTL_MARK)
            p1++;
        while (*p2 == UNICODE_LTR_MARK || *p2 == UNICODE_RTL_MARK)
            p2++;
        p1++;
        p2++;
    }
    *p1 = '\0';
    ok(lstrcmpW(buff2,