ReactOS 0.4.16-dev-1946-g52006dd
Classes | Functions | Variables
IsQSForward.cpp File Reference
#include <apitest.h>
#include <docobj.h>
#include <shlobj.h>
#include <shlwapi.h>
#include <shlwapi_undoc.h>
#include <pseh/pseh2.h>
#include <versionhelpers.h>
Include dependency graph for IsQSForward.cpp:

Go to the source code of this file.

Classes

class  CDummyClass
 

Functions

static HRESULT IsQSForwardMockup (_In_opt_ const GUID *pguidCmdGroup, _In_ ULONG cCmds, _In_ OLECMD *prgCmds)
 
static HRESULT MayQSForwardMockup (_In_ IUnknown *lpUnknown, _In_ INT nUnknown, _In_opt_ const GUID *riidCmdGrp, _In_ ULONG cCmds, _Inout_ OLECMD *prgCmds, _Inout_ OLECMDTEXT *pCmdText)
 
static HRESULT MayExecForwardMockup (_In_ IUnknown *lpUnknown, _In_ INT nUnknown, _In_opt_ const GUID *pguidCmdGroup, _In_ DWORD nCmdID, _In_ DWORD nCmdexecopt, _In_ VARIANT *pvaIn, _Inout_ VARIANT *pvaOut)
 
static VOID TEST_IsQSForward (VOID)
 
static VOID TEST_MayQSForwardMockup (VOID)
 
static VOID TEST_MayExecForwardMockup (VOID)
 
 START_TEST (IsQSForward)
 

Variables

static const BOOL g_bWin8 = IsWindows8OrGreater()
 
static BOOL g_bQueryStatus = FALSE
 
static BOOL g_bExec = FALSE
 

Function Documentation

◆ IsQSForwardMockup()

static HRESULT IsQSForwardMockup ( _In_opt_ const GUID *  pguidCmdGroup,
_In_ ULONG  cCmds,
_In_ OLECMD *  prgCmds 
)
static

Definition at line 19 of file IsQSForward.cpp.

20{
21 DWORD cmdFlags = 0;
22 OLECMDID cmdID;
23 ULONG iCmd;
24 enum {
25 CMD_FLAG_SUPPORTED_BASIC = 0x1,
26 CMD_FLAG_SUPPORTED_ADVANCED = 0x2,
27 CMD_FLAG_NOT_SUPPORTED = 0x4,
28 };
29
30 //TRACE("(%s, %lu, %p)\n", wine_dbgstr_guid(pguidCmdGroup), cCmds, prgCmds);
31
32 if ((LONG)cCmds <= 0)
33 return OLECMDERR_E_NOTSUPPORTED;
34
35 if (!pguidCmdGroup)
36 {
37 for (iCmd = 0; iCmd < cCmds; ++iCmd)
38 {
39 cmdID = (OLECMDID)prgCmds[iCmd].cmdID;
40 if (cmdID <= OLECMDID_PROPERTIES)
41 {
42 cmdFlags |= CMD_FLAG_NOT_SUPPORTED; // Not supported
43 continue;
44 }
45
46 if (cmdID <= OLECMDID_PASTE || cmdID == OLECMDID_SELECTALL)
47 {
48 cmdFlags |= CMD_FLAG_SUPPORTED_BASIC;
49 continue;
50 }
51
52 if (cmdID <= OLECMDID_UPDATECOMMANDS ||
53 (OLECMDID_HIDETOOLBARS <= cmdID && cmdID != OLECMDID_ENABLE_INTERACTION))
54 {
55 cmdFlags |= CMD_FLAG_NOT_SUPPORTED; // Not supported
56 continue;
57 }
58
59 cmdFlags |= CMD_FLAG_SUPPORTED_ADVANCED;
60 }
61 }
62 else
63 {
64 if (!IsEqualGUID(CGID_Explorer, *pguidCmdGroup))
65 {
66 if (g_bWin8)
67 return OLECMDERR_E_UNKNOWNGROUP;
68 else
69 return OLECMDERR_E_NOTSUPPORTED;
70 }
71
72 for (iCmd = 0; iCmd < cCmds; ++iCmd)
73 {
74 cmdID = (OLECMDID)prgCmds[iCmd].cmdID;
75 if (cmdID == OLECMDID_SELECTALL ||
76 (OLECMDID_SHOWFIND <= cmdID && cmdID <= OLECMDID_SHOWPRINT))
77 {
78 cmdFlags |= CMD_FLAG_SUPPORTED_BASIC;
79 break;
80 }
81 }
82 }
83
84 if (!cmdFlags || (cmdFlags & CMD_FLAG_NOT_SUPPORTED))
85 return OLECMDERR_E_NOTSUPPORTED; // Not supported
86
87 return MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL, cmdFlags);
88}
g_bWin8
static const BOOL g_bWin8
Definition: IsQSForward.cpp:16
MAKE_HRESULT
#define MAKE_HRESULT(sev, fac, code)
Definition: dmerror.h:29
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
LONG
long LONG
Definition: pedump.c:60
IsEqualGUID
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
ULONG
uint32_t ULONG
Definition: typedefs.h:59
FACILITY_NULL
#define FACILITY_NULL
Definition: winerror.h:24
SEVERITY_SUCCESS
#define SEVERITY_SUCCESS
Definition: winerror.h:177

Referenced by MayExecForwardMockup(), MayQSForwardMockup(), and TEST_IsQSForward().

◆ MayExecForwardMockup()

static HRESULT MayExecForwardMockup ( _In_ IUnknown *  lpUnknown,
_In_ INT  nUnknown,
_In_opt_ const GUID *  pguidCmdGroup,
_In_ DWORD  nCmdID,
_In_ DWORD  nCmdexecopt,
_In_ VARIANT *  pvaIn,
_Inout_ VARIANT *  pvaOut 
)
static

Definition at line 110 of file IsQSForward.cpp.

118{
119 //TRACE("(%p, %d, %s, %d, %d, %p, %p)\n", lpUnknown, nUnknown,
120 // wine_dbgstr_guid(pguidCmdGroup), nCmdID, nCmdexecopt, pvaIn, pvaOut);
121
122 OLECMD cmd = { nCmdID };
123 HRESULT hr = IsQSForwardMockup(pguidCmdGroup, 1, &cmd);
124 if (FAILED(hr) || !HRESULT_CODE(hr) || nUnknown <= 0)
125 return OLECMDERR_E_NOTSUPPORTED;
126
127 return IUnknown_Exec(lpUnknown, *pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
128}
IsQSForwardMockup
static HRESULT IsQSForwardMockup(_In_opt_ const GUID *pguidCmdGroup, _In_ ULONG cCmds, _In_ OLECMD *prgCmds)
Definition: IsQSForward.cpp:19
IUnknown_Exec
HRESULT WINAPI IUnknown_Exec(IUnknown *lpUnknown, REFGUID pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
Definition: ordinal.c:1087
FAILED
#define FAILED(hr)
Definition: intsafe.h:51
hr
HRESULT hr
Definition: shlfolder.c:183
cmd
Definition: ftp_var.h:139
HRESULT_CODE
#define HRESULT_CODE(hr)
Definition: winerror.h:188

Referenced by TEST_MayExecForwardMockup().

◆ MayQSForwardMockup()

static HRESULT MayQSForwardMockup ( _In_ IUnknown *  lpUnknown,
_In_ INT  nUnknown,
_In_opt_ const GUID *  riidCmdGrp,
_In_ ULONG  cCmds,
_Inout_ OLECMD *  prgCmds,
_Inout_ OLECMDTEXT *  pCmdText 
)
static

Definition at line 91 of file IsQSForward.cpp.

98{
99 //TRACE("(%p, %d, %s, %d, %p, %p)\n",
100 // lpUnknown, nUnknown, wine_dbgstr_guid(riidCmdGrp), cCmds, prgCmds, pCmdText);
101
102 HRESULT hr = IsQSForwardMockup(riidCmdGrp, cCmds, prgCmds);
103 if (FAILED(hr) || !HRESULT_CODE(hr) || nUnknown <= 0)
104 return OLECMDERR_E_NOTSUPPORTED;
105
106 return IUnknown_QueryStatus(lpUnknown, *riidCmdGrp, cCmds, prgCmds, pCmdText);
107}
IUnknown_QueryStatus
HRESULT WINAPI IUnknown_QueryStatus(IUnknown *lpUnknown, REFGUID pguidCmdGroup, ULONG cCmds, OLECMD *prgCmds, OLECMDTEXT *pCmdText)
Definition: ordinal.c:1048

Referenced by TEST_MayQSForwardMockup().

◆ START_TEST()

START_TEST ( IsQSForward  )

Definition at line 364 of file IsQSForward.cpp.

365{
366 TEST_IsQSForward();
367 TEST_MayQSForwardMockup();
368 TEST_MayExecForwardMockup();
369}
TEST_MayExecForwardMockup
static VOID TEST_MayExecForwardMockup(VOID)
Definition: IsQSForward.cpp:327
TEST_MayQSForwardMockup
static VOID TEST_MayQSForwardMockup(VOID)
Definition: IsQSForward.cpp:288
TEST_IsQSForward
static VOID TEST_IsQSForward(VOID)
Definition: IsQSForward.cpp:189

◆ TEST_IsQSForward()

static VOID TEST_IsQSForward ( VOID  )
static

Definition at line 189 of file IsQSForward.cpp.

190{
191 OLECMD cmds[2];
192 LONG cmdID, cmdID2;
193 HRESULT ret1, ret2;
194 ULONG cCmds;
195 BOOL bExcept1, bExcept2;
196 const GUID *pGUID;
197 enum { LOW_VALUE = -1, HIGH_VALUE = OLECMDID_CLOSE };
198
199 cmds[0].cmdf = 0;
200
201 cCmds = 0;
202 pGUID = NULL;
203 for (cmdID = LOW_VALUE; cmdID <= HIGH_VALUE; ++cmdID)
204 {
205 cmds[0].cmdID = cmdID;
206
207 ret1 = IsQSForward(*pGUID, cCmds, cmds);
208 ret2 = IsQSForwardMockup(pGUID, cCmds, cmds);
209 ok(ret1 == ret2, "cmdID: %ld (%ld vs %ld)\n", cmdID, ret1, ret2);
210
211 ret1 = IsQSForward(*pGUID, cCmds, NULL);
212 ret2 = IsQSForwardMockup(pGUID, cCmds, NULL);
213 ok(ret1 == ret2, "cmdID: %ld (%ld vs %ld)\n", cmdID, ret1, ret2);
214 }
215
216 cCmds = 1;
217 for (cmdID = LOW_VALUE; cmdID <= HIGH_VALUE; ++cmdID)
218 {
219 cmds[0].cmdID = cmdID;
220
221 pGUID = NULL;
222 ret1 = IsQSForward(*pGUID, cCmds, cmds);
223 ret2 = IsQSForwardMockup(pGUID, cCmds, cmds);
224 ok(ret1 == ret2, "cmdID: %ld (%ld vs %ld)\n", cmdID, ret1, ret2);
225
226 ret1 = ret2 = 0xDEADFACE;
227 bExcept1 = bExcept2 = FALSE;
228
229 _SEH2_TRY
230 {
231 ret1 = IsQSForward(*pGUID, cCmds, NULL);
232 }
233 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
234 {
235 bExcept1 = TRUE;
236 }
237 _SEH2_END;
238
239 _SEH2_TRY
240 {
241 ret2 = IsQSForwardMockup(pGUID, cCmds, NULL);
242 }
243 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
244 {
245 bExcept2 = TRUE;
246 }
247 _SEH2_END;
248
249 ok(ret1 == ret2, "cmdID: %ld (%ld vs %ld)\n", cmdID, ret1, ret2);
250 ok((bExcept1 && bExcept2), "cmdID: %ld (%d vs %d)\n", cmdID, bExcept1, bExcept2);
251
252 pGUID = &CGID_Explorer;
253 ret1 = IsQSForward(*pGUID, cCmds, cmds);
254 ret2 = IsQSForwardMockup(pGUID, cCmds, cmds);
255 ok(ret1 == ret2, "cmdID: %ld (%ld vs %ld)\n", cmdID, ret1, ret2);
256
257 pGUID = &IID_IUnknown;
258 ret1 = IsQSForward(*pGUID, cCmds, cmds);
259 ret2 = IsQSForwardMockup(pGUID, cCmds, cmds);
260 ok(ret1 == ret2, "cmdID: %ld (%ld vs %ld)\n", cmdID, ret1, ret2);
261 }
262
263 cCmds = 2;
264 for (cmdID = LOW_VALUE; cmdID <= HIGH_VALUE; ++cmdID)
265 {
266 cmds[0].cmdID = cmdID;
267
268 pGUID = NULL;
269 for (cmdID2 = LOW_VALUE; cmdID2 <= HIGH_VALUE; ++cmdID2)
270 {
271 cmds[1].cmdID = cmdID2;
272 ret1 = IsQSForward(*pGUID, cCmds, cmds);
273 ret2 = IsQSForwardMockup(pGUID, cCmds, cmds);
274 ok(ret1 == ret2, "cmdID: %ld (%ld vs %ld)\n", cmdID, ret1, ret2);
275 }
276
277 pGUID = &CGID_Explorer;
278 for (cmdID2 = LOW_VALUE; cmdID2 <= HIGH_VALUE; ++cmdID2)
279 {
280 cmds[1].cmdID = cmdID2;
281 ret1 = IsQSForward(*pGUID, cCmds, cmds);
282 ret2 = IsQSForwardMockup(pGUID, cCmds, cmds);
283 ok(ret1 == ret2, "cmdID: %ld (%ld vs %ld)\n", cmdID, ret1, ret2);
284 }
285 }
286}
ok
#define ok(value,...)
Definition: atltest.h:57
cmds
COMMAND cmds[]
Definition: main.c:21
IID_IUnknown
const GUID IID_IUnknown
Definition: classfactory.cpp:11
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
IsQSForward
HRESULT WINAPI IsQSForward(REFGUID pguidCmdGroup, ULONG cCmds, OLECMD *prgCmds)
Definition: ordinal.c:2353
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
EXCEPTION_EXECUTE_HANDLER
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
_SEH2_EXCEPT
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:82
_SEH2_END
#define _SEH2_END
Definition: pseh2_64.h:171
_SEH2_TRY
#define _SEH2_TRY
Definition: pseh2_64.h:71

Referenced by START_TEST().

◆ TEST_MayExecForwardMockup()

static VOID TEST_MayExecForwardMockup ( VOID  )
static

Definition at line 327 of file IsQSForward.cpp.

328{
329 CDummyClass dummy;
330 LONG cmdID;
331 HRESULT ret1, ret2;
332
333 // Testing OLECMDID_PROPERTIES support
334 cmdID = OLECMDID_PROPERTIES;
335
336 g_bQueryStatus = g_bExec = FALSE;
337 ret1 = MayExecForward(&dummy, 1, CGID_Explorer, cmdID, 0, NULL, NULL);
338 ok_int(g_bQueryStatus, FALSE);
339 ok_int(g_bExec, FALSE);
340
341 g_bQueryStatus = g_bExec = FALSE;
342 ret2 = MayExecForwardMockup(&dummy, 1, &CGID_Explorer, cmdID, 0, NULL, NULL);
343 ok_int(g_bQueryStatus, FALSE);
344 ok_int(g_bExec, FALSE);
345
346 ok(ret1 == ret2, "cmdID: %ld (%ld vs %ld)\n", cmdID, ret1, ret2);
347
348 // Testing OLECMDID_SHOWFIND support
349 cmdID = OLECMDID_SHOWFIND;
350
351 g_bQueryStatus = g_bExec = FALSE;
352 ret1 = MayExecForward(&dummy, 1, CGID_Explorer, cmdID, 0, NULL, NULL);
353 ok_int(g_bQueryStatus, FALSE);
354 ok_int(g_bExec, TRUE);
355
356 g_bQueryStatus = g_bExec = FALSE;
357 ret2 = MayExecForwardMockup(&dummy, 1, &CGID_Explorer, cmdID, 0, NULL, NULL);
358 ok_int(g_bQueryStatus, FALSE);
359 ok_int(g_bExec, TRUE);
360
361 ok(ret1 == ret2, "cmdID: %ld (%ld vs %ld)\n", cmdID, ret1, ret2);
362}
g_bQueryStatus
static BOOL g_bQueryStatus
Definition: IsQSForward.cpp:130
MayExecForwardMockup
static HRESULT MayExecForwardMockup(_In_ IUnknown *lpUnknown, _In_ INT nUnknown, _In_opt_ const GUID *pguidCmdGroup, _In_ DWORD nCmdID, _In_ DWORD nCmdexecopt, _In_ VARIANT *pvaIn, _Inout_ VARIANT *pvaOut)
Definition: IsQSForward.cpp:110
g_bExec
static BOOL g_bExec
Definition: IsQSForward.cpp:131
ok_int
#define ok_int(expression, result)
Definition: atltest.h:134
MayExecForward
HRESULT WINAPI MayExecForward(IUnknown *lpUnknown, INT nUnknown, REFGUID pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
Definition: ordinal.c:2265

Referenced by START_TEST().

◆ TEST_MayQSForwardMockup()

static VOID TEST_MayQSForwardMockup ( VOID  )
static

Definition at line 288 of file IsQSForward.cpp.

289{
290 CDummyClass dummy;
291 LONG cmdID;
292 OLECMD cmds[1];
293 OLECMDTEXT cmdText;
294 HRESULT ret1, ret2;
295
296 // Testing OLECMDID_PROPERTIES support
297 cmds[0].cmdID = cmdID = OLECMDID_PROPERTIES;
298
299 g_bQueryStatus = g_bExec = FALSE;
300 ret1 = MayQSForward(&dummy, 1, CGID_Explorer, _countof(cmds), cmds, &cmdText);
301 ok_int(g_bQueryStatus, FALSE);
302 ok_int(g_bExec, FALSE);
303
304 g_bQueryStatus = g_bExec = FALSE;
305 ret2 = MayQSForwardMockup(&dummy, 1, &CGID_Explorer, _countof(cmds), cmds, &cmdText);
306 ok_int(g_bQueryStatus, FALSE);
307 ok_int(g_bExec, FALSE);
308
309 ok(ret1 == ret2, "cmdID: %ld (%ld vs %ld)\n", cmdID, ret1, ret2);
310
311 // Testing OLECMDID_SHOWFIND support
312 cmds[0].cmdID = cmdID = OLECMDID_SHOWFIND;
313
314 g_bQueryStatus = g_bExec = FALSE;
315 ret1 = MayQSForward(&dummy, 1, CGID_Explorer, _countof(cmds), cmds, &cmdText);
316 ok_int(g_bQueryStatus, TRUE);
317 ok_int(g_bExec, FALSE);
318
319 g_bQueryStatus = g_bExec = FALSE;
320 ret2 = MayQSForwardMockup(&dummy, 1, &CGID_Explorer, _countof(cmds), cmds, &cmdText);
321 ok_int(g_bQueryStatus, TRUE);
322 ok_int(g_bExec, FALSE);
323
324 ok(ret1 == ret2, "cmdID: %ld (%ld vs %ld)\n", cmdID, ret1, ret2);
325}
MayQSForwardMockup
static HRESULT MayQSForwardMockup(_In_ IUnknown *lpUnknown, _In_ INT nUnknown, _In_opt_ const GUID *riidCmdGrp, _In_ ULONG cCmds, _Inout_ OLECMD *prgCmds, _Inout_ OLECMDTEXT *pCmdText)
Definition: IsQSForward.cpp:91
MayQSForward
HRESULT WINAPI MayQSForward(IUnknown *lpUnknown, PVOID lpReserved, REFGUID riidCmdGrp, ULONG cCmds, OLECMD *prgCmds, OLECMDTEXT *pCmdText)
Definition: ordinal.c:2227
_countof
#define _countof(array)
Definition: sndvol32.h:70

Referenced by START_TEST().

Variable Documentation

◆ g_bExec

BOOL g_bExec = FALSE
static

Definition at line 131 of file IsQSForward.cpp.

Referenced by CDummyClass::Exec(), TEST_MayExecForwardMockup(), and TEST_MayQSForwardMockup().

◆ g_bQueryStatus

BOOL g_bQueryStatus = FALSE
static

Definition at line 130 of file IsQSForward.cpp.

Referenced by CDummyClass::QueryStatus(), TEST_MayExecForwardMockup(), and TEST_MayQSForwardMockup().

◆ g_bWin8

const BOOL g_bWin8 = IsWindows8OrGreater()
static

Definition at line 16 of file IsQSForward.cpp.

Referenced by IsQSForwardMockup().