ca94904696a34e60c4628f88a62c8ce531397d4f
[reactos.git] / modules / rostests / winetests / ole32 / moniker.c
1 /*
2 * Moniker Tests
3 *
4 * Copyright 2004 Robert Shearman
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "precomp.h"
22
23 #include <comcat.h>
24 #include <olectl.h>
25
26 #define ok_more_than_one_lock() ok(cLocks > 0, "Number of locks should be > 0, but actually is %d\n", cLocks)
27 #define ok_no_locks() ok(cLocks == 0, "Number of locks should be 0, but actually is %d\n", cLocks)
28 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08x\n", hr)
29 #define COUNTOF(x) (sizeof(x) / sizeof(x[0]))
30
31 #define CHECK_EXPECTED_METHOD(method_name) \
32 do { \
33 trace("%s\n", method_name); \
34 ok(*expected_method_list != NULL, "Extra method %s called\n", method_name); \
35 if (*expected_method_list) \
36 { \
37 ok(!strcmp(*expected_method_list, method_name), "Expected %s to be called instead of %s\n", \
38 *expected_method_list, method_name); \
39 expected_method_list++; \
40 } \
41 } while(0)
42
43 static char const * const *expected_method_list;
44 static const WCHAR wszFileName1[] = {'c',':','\\','w','i','n','d','o','w','s','\\','t','e','s','t','1','.','d','o','c',0};
45 static const WCHAR wszFileName2[] = {'c',':','\\','w','i','n','d','o','w','s','\\','t','e','s','t','2','.','d','o','c',0};
46
47 static const CLSID CLSID_TestMoniker =
48 { /* b306bfbc-496e-4f53-b93e-2ff9c83223d7 */
49 0xb306bfbc,
50 0x496e,
51 0x4f53,
52 {0xb9, 0x3e, 0x2f, 0xf9, 0xc8, 0x32, 0x23, 0xd7}
53 };
54
55 static LONG cLocks;
56
57 static void LockModule(void)
58 {
59 InterlockedIncrement(&cLocks);
60 }
61
62 static void UnlockModule(void)
63 {
64 InterlockedDecrement(&cLocks);
65 }
66
67 static SIZE_T round_global_size(SIZE_T size)
68 {
69 static SIZE_T global_size_alignment = -1;
70 if (global_size_alignment == -1)
71 {
72 void *p = GlobalAlloc(GMEM_FIXED, 1);
73 global_size_alignment = GlobalSize(p);
74 GlobalFree(p);
75 }
76
77 return ((size + global_size_alignment - 1) & ~(global_size_alignment - 1));
78 }
79
80 static DWORD external_connections;
81
82 static HRESULT WINAPI ExternalConnection_QueryInterface(IExternalConnection *iface, REFIID riid, void **ppv)
83 {
84 ok(0, "unexpected call\n");
85 *ppv = NULL;
86 return E_NOINTERFACE;
87 }
88
89 static ULONG WINAPI ExternalConnection_AddRef(IExternalConnection *iface)
90 {
91 return 2;
92 }
93
94 static ULONG WINAPI ExternalConnection_Release(IExternalConnection *iface)
95 {
96 return 1;
97 }
98
99 static DWORD WINAPI ExternalConnection_AddConnection(IExternalConnection *iface, DWORD extconn, DWORD reserved)
100 {
101 trace("add connection\n");
102
103 ok(extconn == EXTCONN_STRONG, "extconn = %d\n", extconn);
104 ok(!reserved, "reserved = %x\n", reserved);
105 return ++external_connections;
106 }
107
108 static DWORD WINAPI ExternalConnection_ReleaseConnection(IExternalConnection *iface, DWORD extconn,
109 DWORD reserved, BOOL fLastReleaseCloses)
110 {
111 trace("release connection\n");
112
113 ok(extconn == EXTCONN_STRONG, "extconn = %d\n", extconn);
114 ok(!reserved, "reserved = %x\n", reserved);
115
116 return --external_connections;
117 }
118
119 static const IExternalConnectionVtbl ExternalConnectionVtbl = {
120 ExternalConnection_QueryInterface,
121 ExternalConnection_AddRef,
122 ExternalConnection_Release,
123 ExternalConnection_AddConnection,
124 ExternalConnection_ReleaseConnection
125 };
126
127 static IExternalConnection ExternalConnection = { &ExternalConnectionVtbl };
128
129 static HRESULT WINAPI Test_IClassFactory_QueryInterface(
130 LPCLASSFACTORY iface,
131 REFIID riid,
132 LPVOID *ppvObj)
133 {
134 if (ppvObj == NULL) return E_POINTER;
135
136 if (IsEqualGUID(riid, &IID_IUnknown) ||
137 IsEqualGUID(riid, &IID_IClassFactory))
138 {
139 *ppvObj = iface;
140 IClassFactory_AddRef(iface);
141 return S_OK;
142 }
143
144 if(IsEqualGUID(riid, &IID_IExternalConnection)) {
145 *ppvObj = &ExternalConnection;
146 return S_OK;
147 }
148
149 *ppvObj = NULL;
150 return E_NOINTERFACE;
151 }
152
153 static ULONG WINAPI Test_IClassFactory_AddRef(LPCLASSFACTORY iface)
154 {
155 LockModule();
156 return 2; /* non-heap-based object */
157 }
158
159 static ULONG WINAPI Test_IClassFactory_Release(LPCLASSFACTORY iface)
160 {
161 UnlockModule();
162 return 1; /* non-heap-based object */
163 }
164
165 static HRESULT WINAPI Test_IClassFactory_CreateInstance(
166 LPCLASSFACTORY iface,
167 LPUNKNOWN pUnkOuter,
168 REFIID riid,
169 LPVOID *ppvObj)
170 {
171 return E_NOTIMPL;
172 }
173
174 static HRESULT WINAPI Test_IClassFactory_LockServer(
175 LPCLASSFACTORY iface,
176 BOOL fLock)
177 {
178 return S_OK;
179 }
180
181 static const IClassFactoryVtbl TestClassFactory_Vtbl =
182 {
183 Test_IClassFactory_QueryInterface,
184 Test_IClassFactory_AddRef,
185 Test_IClassFactory_Release,
186 Test_IClassFactory_CreateInstance,
187 Test_IClassFactory_LockServer
188 };
189
190 static IClassFactory Test_ClassFactory = { &TestClassFactory_Vtbl };
191
192 typedef struct
193 {
194 IUnknown IUnknown_iface;
195 ULONG refs;
196 } HeapUnknown;
197
198 static inline HeapUnknown *impl_from_IUnknown(IUnknown *iface)
199 {
200 return CONTAINING_RECORD(iface, HeapUnknown, IUnknown_iface);
201 }
202
203 static HRESULT WINAPI HeapUnknown_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
204 {
205 if (IsEqualIID(riid, &IID_IUnknown))
206 {
207 IUnknown_AddRef(iface);
208 *ppv = iface;
209 return S_OK;
210 }
211 *ppv = NULL;
212 return E_NOINTERFACE;
213 }
214
215 static ULONG WINAPI HeapUnknown_AddRef(IUnknown *iface)
216 {
217 HeapUnknown *This = impl_from_IUnknown(iface);
218 return InterlockedIncrement((LONG*)&This->refs);
219 }
220
221 static ULONG WINAPI HeapUnknown_Release(IUnknown *iface)
222 {
223 HeapUnknown *This = impl_from_IUnknown(iface);
224 ULONG refs = InterlockedDecrement((LONG*)&This->refs);
225 if (!refs) HeapFree(GetProcessHeap(), 0, This);
226 return refs;
227 }
228
229 static const IUnknownVtbl HeapUnknown_Vtbl =
230 {
231 HeapUnknown_QueryInterface,
232 HeapUnknown_AddRef,
233 HeapUnknown_Release
234 };
235
236 static HRESULT WINAPI
237 MonikerNoROTData_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
238 {
239 if (!ppvObject)
240 return E_INVALIDARG;
241
242 *ppvObject = 0;
243
244 if (IsEqualIID(&IID_IUnknown, riid) ||
245 IsEqualIID(&IID_IPersist, riid) ||
246 IsEqualIID(&IID_IPersistStream,riid) ||
247 IsEqualIID(&IID_IMoniker, riid))
248 *ppvObject = iface;
249 if (IsEqualIID(&IID_IROTData, riid))
250 CHECK_EXPECTED_METHOD("Moniker_QueryInterface(IID_IROTData)");
251
252 if ((*ppvObject)==0)
253 return E_NOINTERFACE;
254
255 IMoniker_AddRef(iface);
256
257 return S_OK;
258 }
259
260 static ULONG WINAPI
261 Moniker_AddRef(IMoniker* iface)
262 {
263 return 2;
264 }
265
266 static ULONG WINAPI
267 Moniker_Release(IMoniker* iface)
268 {
269 return 1;
270 }
271
272 static HRESULT WINAPI
273 Moniker_GetClassID(IMoniker* iface, CLSID *pClassID)
274 {
275 CHECK_EXPECTED_METHOD("Moniker_GetClassID");
276
277 *pClassID = CLSID_TestMoniker;
278
279 return S_OK;
280 }
281
282 static HRESULT WINAPI
283 Moniker_IsDirty(IMoniker* iface)
284 {
285 CHECK_EXPECTED_METHOD("Moniker_IsDirty");
286
287 return S_FALSE;
288 }
289
290 static HRESULT WINAPI
291 Moniker_Load(IMoniker* iface, IStream* pStm)
292 {
293 CHECK_EXPECTED_METHOD("Moniker_Load");
294 return E_NOTIMPL;
295 }
296
297 static HRESULT WINAPI
298 Moniker_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty)
299 {
300 CHECK_EXPECTED_METHOD("Moniker_Save");
301 return E_NOTIMPL;
302 }
303
304 static HRESULT WINAPI
305 Moniker_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize)
306 {
307 CHECK_EXPECTED_METHOD("Moniker_GetSizeMax");
308 return E_NOTIMPL;
309 }
310
311 static HRESULT WINAPI
312 Moniker_BindToObject(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
313 REFIID riid, VOID** ppvResult)
314 {
315 CHECK_EXPECTED_METHOD("Moniker_BindToObject");
316 return E_NOTIMPL;
317 }
318
319 static HRESULT WINAPI
320 Moniker_BindToStorage(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
321 REFIID riid, VOID** ppvObject)
322 {
323 CHECK_EXPECTED_METHOD("Moniker_BindToStorage");
324 return E_NOTIMPL;
325 }
326
327 static HRESULT WINAPI
328 Moniker_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar,
329 IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
330 {
331 CHECK_EXPECTED_METHOD("Moniker_Reduce");
332
333 if (ppmkReduced==NULL)
334 return E_POINTER;
335
336 IMoniker_AddRef(iface);
337
338 *ppmkReduced=iface;
339
340 return MK_S_REDUCED_TO_SELF;
341 }
342
343 static HRESULT WINAPI
344 Moniker_ComposeWith(IMoniker* iface, IMoniker* pmkRight,
345 BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
346 {
347 CHECK_EXPECTED_METHOD("Moniker_ComposeWith");
348 return E_NOTIMPL;
349 }
350
351 static HRESULT WINAPI
352 Moniker_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
353 {
354 CHECK_EXPECTED_METHOD("Moniker_Enum");
355
356 if (ppenumMoniker == NULL)
357 return E_POINTER;
358
359 *ppenumMoniker = NULL;
360
361 return S_OK;
362 }
363
364 static HRESULT WINAPI
365 Moniker_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
366 {
367 CHECK_EXPECTED_METHOD("Moniker_IsEqual");
368 return E_NOTIMPL;
369 }
370
371 static HRESULT WINAPI
372 Moniker_Hash(IMoniker* iface,DWORD* pdwHash)
373 {
374 CHECK_EXPECTED_METHOD("Moniker_Hash");
375 return E_NOTIMPL;
376 }
377
378 static HRESULT WINAPI
379 Moniker_IsRunning(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
380 IMoniker* pmkNewlyRunning)
381 {
382 CHECK_EXPECTED_METHOD("Moniker_IsRunning");
383 return E_NOTIMPL;
384 }
385
386 static HRESULT WINAPI
387 Moniker_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc,
388 IMoniker* pmkToLeft, FILETIME* pFileTime)
389 {
390 CHECK_EXPECTED_METHOD("Moniker_GetTimeOfLastChange");
391 return E_NOTIMPL;
392 }
393
394 static HRESULT WINAPI
395 Moniker_Inverse(IMoniker* iface,IMoniker** ppmk)
396 {
397 CHECK_EXPECTED_METHOD("Moniker_Inverse");
398 return E_NOTIMPL;
399 }
400
401 static HRESULT WINAPI
402 Moniker_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
403 {
404 CHECK_EXPECTED_METHOD("Moniker_CommonPrefixWith");
405 return E_NOTIMPL;
406 }
407
408 static HRESULT WINAPI
409 Moniker_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
410 {
411 CHECK_EXPECTED_METHOD("Moniker_RelativePathTo");
412 return E_NOTIMPL;
413 }
414
415 static HRESULT WINAPI
416 Moniker_GetDisplayName(IMoniker* iface, IBindCtx* pbc,
417 IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName)
418 {
419 static const WCHAR wszDisplayName[] = {'*','*','G','e','m','m','a',0};
420 CHECK_EXPECTED_METHOD("Moniker_GetDisplayName");
421 *ppszDisplayName = CoTaskMemAlloc(sizeof(wszDisplayName));
422 memcpy(*ppszDisplayName, wszDisplayName, sizeof(wszDisplayName));
423 return S_OK;
424 }
425
426 static HRESULT WINAPI
427 Moniker_ParseDisplayName(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
428 LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut)
429 {
430 CHECK_EXPECTED_METHOD("Moniker_ParseDisplayName");
431 return E_NOTIMPL;
432 }
433
434 static HRESULT WINAPI
435 Moniker_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
436 {
437 CHECK_EXPECTED_METHOD("Moniker_IsSystemMoniker");
438
439 if (!pwdMksys)
440 return E_POINTER;
441
442 (*pwdMksys)=MKSYS_NONE;
443
444 return S_FALSE;
445 }
446
447 static const IMonikerVtbl MonikerNoROTDataVtbl =
448 {
449 MonikerNoROTData_QueryInterface,
450 Moniker_AddRef,
451 Moniker_Release,
452 Moniker_GetClassID,
453 Moniker_IsDirty,
454 Moniker_Load,
455 Moniker_Save,
456 Moniker_GetSizeMax,
457 Moniker_BindToObject,
458 Moniker_BindToStorage,
459 Moniker_Reduce,
460 Moniker_ComposeWith,
461 Moniker_Enum,
462 Moniker_IsEqual,
463 Moniker_Hash,
464 Moniker_IsRunning,
465 Moniker_GetTimeOfLastChange,
466 Moniker_Inverse,
467 Moniker_CommonPrefixWith,
468 Moniker_RelativePathTo,
469 Moniker_GetDisplayName,
470 Moniker_ParseDisplayName,
471 Moniker_IsSystemMoniker
472 };
473
474 static IMoniker MonikerNoROTData = { &MonikerNoROTDataVtbl };
475
476 static IMoniker Moniker;
477
478 static HRESULT WINAPI
479 ROTData_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
480 {
481 return IMoniker_QueryInterface(&Moniker, riid, ppvObject);
482 }
483
484 static ULONG WINAPI
485 ROTData_AddRef(IROTData *iface)
486 {
487 return 2;
488 }
489
490 static ULONG WINAPI
491 ROTData_Release(IROTData* iface)
492 {
493 return 1;
494 }
495
496 static HRESULT WINAPI
497 ROTData_GetComparisonData(IROTData* iface, BYTE* pbData,
498 ULONG cbMax, ULONG* pcbData)
499 {
500 CHECK_EXPECTED_METHOD("ROTData_GetComparisonData");
501
502 *pcbData = 1;
503 if (cbMax < *pcbData)
504 return E_OUTOFMEMORY;
505
506 *pbData = 0xde;
507
508 return S_OK;
509 }
510
511 static IROTDataVtbl ROTDataVtbl =
512 {
513 ROTData_QueryInterface,
514 ROTData_AddRef,
515 ROTData_Release,
516 ROTData_GetComparisonData
517 };
518
519 static IROTData ROTData = { &ROTDataVtbl };
520
521 static HRESULT WINAPI
522 Moniker_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
523 {
524 if (!ppvObject)
525 return E_INVALIDARG;
526
527 *ppvObject = 0;
528
529 if (IsEqualIID(&IID_IUnknown, riid) ||
530 IsEqualIID(&IID_IPersist, riid) ||
531 IsEqualIID(&IID_IPersistStream,riid) ||
532 IsEqualIID(&IID_IMoniker, riid))
533 *ppvObject = iface;
534 if (IsEqualIID(&IID_IROTData, riid))
535 {
536 CHECK_EXPECTED_METHOD("Moniker_QueryInterface(IID_IROTData)");
537 *ppvObject = &ROTData;
538 }
539
540 if ((*ppvObject)==0)
541 return E_NOINTERFACE;
542
543 IMoniker_AddRef(iface);
544
545 return S_OK;
546 }
547
548 static const IMonikerVtbl MonikerVtbl =
549 {
550 Moniker_QueryInterface,
551 Moniker_AddRef,
552 Moniker_Release,
553 Moniker_GetClassID,
554 Moniker_IsDirty,
555 Moniker_Load,
556 Moniker_Save,
557 Moniker_GetSizeMax,
558 Moniker_BindToObject,
559 Moniker_BindToStorage,
560 Moniker_Reduce,
561 Moniker_ComposeWith,
562 Moniker_Enum,
563 Moniker_IsEqual,
564 Moniker_Hash,
565 Moniker_IsRunning,
566 Moniker_GetTimeOfLastChange,
567 Moniker_Inverse,
568 Moniker_CommonPrefixWith,
569 Moniker_RelativePathTo,
570 Moniker_GetDisplayName,
571 Moniker_ParseDisplayName,
572 Moniker_IsSystemMoniker
573 };
574
575 static IMoniker Moniker = { &MonikerVtbl };
576
577 static void test_ROT(void)
578 {
579 static const WCHAR wszFileName[] = {'B','E','2','0','E','2','F','5','-',
580 '1','9','0','3','-','4','A','A','E','-','B','1','A','F','-',
581 '2','0','4','6','E','5','8','6','C','9','2','5',0};
582 HRESULT hr;
583 IMoniker *pMoniker = NULL;
584 IRunningObjectTable *pROT = NULL;
585 DWORD dwCookie;
586 static const char *methods_register_no_ROTData[] =
587 {
588 "Moniker_Reduce",
589 "Moniker_GetTimeOfLastChange",
590 "Moniker_QueryInterface(IID_IROTData)",
591 "Moniker_GetDisplayName",
592 "Moniker_GetClassID",
593 NULL
594 };
595 static const char *methods_register[] =
596 {
597 "Moniker_Reduce",
598 "Moniker_GetTimeOfLastChange",
599 "Moniker_QueryInterface(IID_IROTData)",
600 "ROTData_GetComparisonData",
601 NULL
602 };
603 static const char *methods_isrunning_no_ROTData[] =
604 {
605 "Moniker_Reduce",
606 "Moniker_QueryInterface(IID_IROTData)",
607 "Moniker_GetDisplayName",
608 "Moniker_GetClassID",
609 NULL
610 };
611 static const char *methods_isrunning[] =
612 {
613 "Moniker_Reduce",
614 "Moniker_QueryInterface(IID_IROTData)",
615 "ROTData_GetComparisonData",
616 NULL
617 };
618
619 cLocks = 0;
620
621 hr = GetRunningObjectTable(0, &pROT);
622 ok_ole_success(hr, GetRunningObjectTable);
623
624 expected_method_list = methods_register_no_ROTData;
625 external_connections = 0;
626 /* try with our own moniker that doesn't support IROTData */
627 hr = IRunningObjectTable_Register(pROT, ROTFLAGS_REGISTRATIONKEEPSALIVE,
628 (IUnknown*)&Test_ClassFactory, &MonikerNoROTData, &dwCookie);
629 ok_ole_success(hr, IRunningObjectTable_Register);
630 ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
631 ok(external_connections == 1, "external_connections = %d\n", external_connections);
632
633 ok_more_than_one_lock();
634
635 expected_method_list = methods_isrunning_no_ROTData;
636 hr = IRunningObjectTable_IsRunning(pROT, &MonikerNoROTData);
637 ok_ole_success(hr, IRunningObjectTable_IsRunning);
638 ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
639
640 hr = IRunningObjectTable_Revoke(pROT, dwCookie);
641 ok_ole_success(hr, IRunningObjectTable_Revoke);
642 ok(external_connections == 0, "external_connections = %d\n", external_connections);
643
644 ok_no_locks();
645
646 expected_method_list = methods_register;
647 /* try with our own moniker */
648 hr = IRunningObjectTable_Register(pROT, ROTFLAGS_REGISTRATIONKEEPSALIVE,
649 (IUnknown*)&Test_ClassFactory, &Moniker, &dwCookie);
650 ok_ole_success(hr, IRunningObjectTable_Register);
651 ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
652
653 ok_more_than_one_lock();
654
655 expected_method_list = methods_isrunning;
656 hr = IRunningObjectTable_IsRunning(pROT, &Moniker);
657 ok_ole_success(hr, IRunningObjectTable_IsRunning);
658 ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
659
660 hr = IRunningObjectTable_Revoke(pROT, dwCookie);
661 ok_ole_success(hr, IRunningObjectTable_Revoke);
662
663 ok_no_locks();
664
665 hr = CreateFileMoniker(wszFileName, &pMoniker);
666 ok_ole_success(hr, CreateClassMoniker);
667
668 /* test flags: 0 */
669 external_connections = 0;
670 hr = IRunningObjectTable_Register(pROT, 0, (IUnknown*)&Test_ClassFactory,
671 pMoniker, &dwCookie);
672 ok_ole_success(hr, IRunningObjectTable_Register);
673 ok(external_connections == 0, "external_connections = %d\n", external_connections);
674
675 ok_more_than_one_lock();
676
677 hr = IRunningObjectTable_Revoke(pROT, dwCookie);
678 ok_ole_success(hr, IRunningObjectTable_Revoke);
679
680 ok_no_locks();
681
682 /* test flags: ROTFLAGS_REGISTRATIONKEEPSALIVE */
683 hr = IRunningObjectTable_Register(pROT, ROTFLAGS_REGISTRATIONKEEPSALIVE,
684 (IUnknown*)&Test_ClassFactory, pMoniker, &dwCookie);
685 ok_ole_success(hr, IRunningObjectTable_Register);
686
687 ok_more_than_one_lock();
688
689 hr = IRunningObjectTable_Revoke(pROT, dwCookie);
690 ok_ole_success(hr, IRunningObjectTable_Revoke);
691
692 ok_no_locks();
693
694 /* test flags: ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT */
695 /* only succeeds when process is started by SCM and has LocalService
696 * or RunAs AppId values */
697 hr = IRunningObjectTable_Register(pROT,
698 ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT,
699 (IUnknown*)&Test_ClassFactory, pMoniker, &dwCookie);
700 todo_wine {
701 ok(hr == CO_E_WRONG_SERVER_IDENTITY ||
702 broken(hr == S_OK) /* Win9x */,
703 "IRunningObjectTable_Register should have returned CO_E_WRONG_SERVER_IDENTITY instead of 0x%08x\n", hr);
704 }
705 if (hr == S_OK) IRunningObjectTable_Revoke(pROT, dwCookie);
706
707 hr = IRunningObjectTable_Register(pROT, 0xdeadbeef,
708 (IUnknown*)&Test_ClassFactory, pMoniker, &dwCookie);
709 ok(hr == E_INVALIDARG, "IRunningObjectTable_Register should have returned E_INVALIDARG instead of 0x%08x\n", hr);
710
711 IMoniker_Release(pMoniker);
712
713 IRunningObjectTable_Release(pROT);
714 }
715
716 static void test_ROT_multiple_entries(void)
717 {
718 HRESULT hr;
719 IMoniker *pMoniker = NULL;
720 IRunningObjectTable *pROT = NULL;
721 DWORD dwCookie1, dwCookie2;
722 IUnknown *pObject = NULL;
723 static const WCHAR moniker_path[] =
724 {'\\', 'w','i','n','d','o','w','s','\\','s','y','s','t','e','m','\\','t','e','s','t','1','.','d','o','c',0};
725
726 hr = GetRunningObjectTable(0, &pROT);
727 ok_ole_success(hr, GetRunningObjectTable);
728
729 hr = CreateFileMoniker(moniker_path, &pMoniker);
730 ok_ole_success(hr, CreateFileMoniker);
731
732 hr = IRunningObjectTable_Register(pROT, 0, (IUnknown *)&Test_ClassFactory, pMoniker, &dwCookie1);
733 ok_ole_success(hr, IRunningObjectTable_Register);
734
735 hr = IRunningObjectTable_Register(pROT, 0, (IUnknown *)&Test_ClassFactory, pMoniker, &dwCookie2);
736 ok(hr == MK_S_MONIKERALREADYREGISTERED, "IRunningObjectTable_Register should have returned MK_S_MONIKERALREADYREGISTERED instead of 0x%08x\n", hr);
737
738 ok(dwCookie1 != dwCookie2, "cookie returned for registering duplicate object shouldn't match cookie of original object (0x%x)\n", dwCookie1);
739
740 hr = IRunningObjectTable_GetObject(pROT, pMoniker, &pObject);
741 ok_ole_success(hr, IRunningObjectTable_GetObject);
742 IUnknown_Release(pObject);
743
744 hr = IRunningObjectTable_Revoke(pROT, dwCookie1);
745 ok_ole_success(hr, IRunningObjectTable_Revoke);
746
747 hr = IRunningObjectTable_GetObject(pROT, pMoniker, &pObject);
748 ok_ole_success(hr, IRunningObjectTable_GetObject);
749 IUnknown_Release(pObject);
750
751 hr = IRunningObjectTable_Revoke(pROT, dwCookie2);
752 ok_ole_success(hr, IRunningObjectTable_Revoke);
753
754 IMoniker_Release(pMoniker);
755
756 IRunningObjectTable_Release(pROT);
757 }
758
759 static HRESULT WINAPI ParseDisplayName_QueryInterface(IParseDisplayName *iface, REFIID riid, void **ppv)
760 {
761 if (IsEqualIID(riid, &IID_IUnknown) ||
762 IsEqualIID(riid, &IID_IParseDisplayName))
763 {
764 *ppv = iface;
765 IParseDisplayName_AddRef(iface);
766 return S_OK;
767 }
768 *ppv = NULL;
769 return E_NOINTERFACE;
770 }
771
772 static ULONG WINAPI ParseDisplayName_AddRef(IParseDisplayName *iface)
773 {
774 return 2;
775 }
776
777 static ULONG WINAPI ParseDisplayName_Release(IParseDisplayName *iface)
778 {
779 return 1;
780 }
781
782 static LPCWSTR expected_display_name;
783
784 static HRESULT WINAPI ParseDisplayName_ParseDisplayName(IParseDisplayName *iface,
785 IBindCtx *pbc,
786 LPOLESTR pszDisplayName,
787 ULONG *pchEaten,
788 IMoniker **ppmkOut)
789 {
790 char display_nameA[256];
791 WideCharToMultiByte(CP_ACP, 0, pszDisplayName, -1, display_nameA, sizeof(display_nameA), NULL, NULL);
792 ok(!lstrcmpW(pszDisplayName, expected_display_name), "unexpected display name \"%s\"\n", display_nameA);
793 ok(pszDisplayName == expected_display_name, "pszDisplayName should be the same pointer as passed into MkParseDisplayName\n");
794 *pchEaten = lstrlenW(pszDisplayName);
795 return CreateAntiMoniker(ppmkOut);
796 }
797
798 static const IParseDisplayNameVtbl ParseDisplayName_Vtbl =
799 {
800 ParseDisplayName_QueryInterface,
801 ParseDisplayName_AddRef,
802 ParseDisplayName_Release,
803 ParseDisplayName_ParseDisplayName
804 };
805
806 static IParseDisplayName ParseDisplayName = { &ParseDisplayName_Vtbl };
807
808 static int count_moniker_matches(IBindCtx * pbc, IEnumMoniker * spEM)
809 {
810 IMoniker * spMoniker;
811 int monCnt=0, matchCnt=0;
812
813 while ((IEnumMoniker_Next(spEM, 1, &spMoniker, NULL)==S_OK))
814 {
815 HRESULT hr;
816 WCHAR * szDisplayn;
817 monCnt++;
818 hr=IMoniker_GetDisplayName(spMoniker, pbc, NULL, &szDisplayn);
819 if (SUCCEEDED(hr))
820 {
821 if (!lstrcmpiW(szDisplayn, wszFileName1) || !lstrcmpiW(szDisplayn, wszFileName2))
822 matchCnt++;
823 CoTaskMemFree(szDisplayn);
824 }
825 }
826 trace("Total number of monikers is %i\n", monCnt);
827 return matchCnt;
828 }
829
830 static void test_MkParseDisplayName(void)
831 {
832 IBindCtx * pbc = NULL;
833 HRESULT hr;
834 IMoniker * pmk = NULL;
835 IMoniker * pmk1 = NULL;
836 IMoniker * pmk2 = NULL;
837 ULONG eaten;
838 int matchCnt;
839 IUnknown * object = NULL;
840
841 IUnknown *lpEM1;
842
843 IEnumMoniker *spEM1 = NULL;
844 IEnumMoniker *spEM2 = NULL;
845 IEnumMoniker *spEM3 = NULL;
846
847 DWORD pdwReg1=0;
848 DWORD grflags=0;
849 DWORD pdwReg2=0;
850 DWORD moniker_type;
851 IRunningObjectTable * pprot=NULL;
852
853 /* CLSID of My Computer */
854 static const WCHAR wszDisplayName[] = {'c','l','s','i','d',':',
855 '2','0','D','0','4','F','E','0','-','3','A','E','A','-','1','0','6','9','-','A','2','D','8','-','0','8','0','0','2','B','3','0','3','0','9','D',':',0};
856 static const WCHAR wszDisplayNameClsid[] = {'c','l','s','i','d',':',0};
857 static const WCHAR wszNonExistentProgId[] = {'N','o','n','E','x','i','s','t','e','n','t','P','r','o','g','I','d',':',0};
858 static const WCHAR wszDisplayNameRunning[] = {'W','i','n','e','T','e','s','t','R','u','n','n','i','n','g',0};
859 static const WCHAR wszDisplayNameProgId1[] = {'S','t','d','F','o','n','t',':',0};
860 static const WCHAR wszDisplayNameProgId2[] = {'@','S','t','d','F','o','n','t',0};
861 static const WCHAR wszDisplayNameProgIdFail[] = {'S','t','d','F','o','n','t',0};
862 static const WCHAR wszEmpty[] = {0};
863 char szDisplayNameFile[256];
864 WCHAR wszDisplayNameFile[256];
865 int i, len;
866
867 const struct
868 {
869 LPBC *ppbc;
870 LPCOLESTR szDisplayName;
871 LPDWORD pchEaten;
872 LPMONIKER *ppmk;
873 } invalid_parameters[] =
874 {
875 {NULL, NULL, NULL, NULL},
876 {NULL, NULL, NULL, &pmk},
877 {NULL, NULL, &eaten, NULL},
878 {NULL, NULL, &eaten, &pmk},
879 {NULL, wszEmpty, NULL, NULL},
880 {NULL, wszEmpty, NULL, &pmk},
881 {NULL, wszEmpty, &eaten, NULL},
882 {NULL, wszEmpty, &eaten, &pmk},
883 {&pbc, NULL, NULL, NULL},
884 {&pbc, NULL, NULL, &pmk},
885 {&pbc, NULL, &eaten, NULL},
886 {&pbc, NULL, &eaten, &pmk},
887 {&pbc, wszEmpty, NULL, NULL},
888 {&pbc, wszEmpty, NULL, &pmk},
889 {&pbc, wszEmpty, &eaten, NULL},
890 {&pbc, wszEmpty, &eaten, &pmk},
891 };
892
893 hr = CreateBindCtx(0, &pbc);
894 ok_ole_success(hr, CreateBindCtx);
895
896 for (i = 0; i < sizeof(invalid_parameters)/sizeof(invalid_parameters[0]); i++)
897 {
898 eaten = 0xdeadbeef;
899 pmk = (IMoniker *)0xdeadbeef;
900 hr = MkParseDisplayName(invalid_parameters[i].ppbc ? *invalid_parameters[i].ppbc : NULL,
901 invalid_parameters[i].szDisplayName,
902 invalid_parameters[i].pchEaten,
903 invalid_parameters[i].ppmk);
904 ok(hr == E_INVALIDARG, "[%d] MkParseDisplayName should have failed with E_INVALIDARG instead of 0x%08x\n", i, hr);
905 ok(eaten == 0xdeadbeef, "[%d] Processed character count should have been 0xdeadbeef instead of %u\n", i, eaten);
906 ok(pmk == (IMoniker *)0xdeadbeef, "[%d] Output moniker pointer should have been 0xdeadbeef instead of %p\n", i, pmk);
907 }
908
909 eaten = 0xdeadbeef;
910 pmk = (IMoniker *)0xdeadbeef;
911 hr = MkParseDisplayName(pbc, wszNonExistentProgId, &eaten, &pmk);
912 ok(hr == MK_E_SYNTAX || hr == MK_E_CANTOPENFILE /* Win9x */,
913 "MkParseDisplayName should have failed with MK_E_SYNTAX or MK_E_CANTOPENFILE instead of 0x%08x\n", hr);
914 ok(eaten == 0, "Processed character count should have been 0 instead of %u\n", eaten);
915 ok(pmk == NULL, "Output moniker pointer should have been NULL instead of %p\n", pmk);
916
917 /* no special handling of "clsid:" without the string form of the clsid
918 * following */
919 eaten = 0xdeadbeef;
920 pmk = (IMoniker *)0xdeadbeef;
921 hr = MkParseDisplayName(pbc, wszDisplayNameClsid, &eaten, &pmk);
922 ok(hr == MK_E_SYNTAX || hr == MK_E_CANTOPENFILE /* Win9x */,
923 "MkParseDisplayName should have failed with MK_E_SYNTAX or MK_E_CANTOPENFILE instead of 0x%08x\n", hr);
924 ok(eaten == 0, "Processed character count should have been 0 instead of %u\n", eaten);
925 ok(pmk == NULL, "Output moniker pointer should have been NULL instead of %p\n", pmk);
926
927 /* shows clsid has higher precedence than a running object */
928 hr = CreateFileMoniker(wszDisplayName, &pmk);
929 ok_ole_success(hr, CreateFileMoniker);
930 hr = IBindCtx_GetRunningObjectTable(pbc, &pprot);
931 ok_ole_success(hr, IBindCtx_GetRunningObjectTable);
932 hr = IRunningObjectTable_Register(pprot, 0, (IUnknown *)&Test_ClassFactory, pmk, &pdwReg1);
933 ok_ole_success(hr, IRunningObjectTable_Register);
934 IMoniker_Release(pmk);
935 pmk = NULL;
936 hr = MkParseDisplayName(pbc, wszDisplayName, &eaten, &pmk);
937 ok_ole_success(hr, MkParseDisplayName);
938 ok(eaten == sizeof(wszDisplayName)/sizeof(WCHAR) - 1,
939 "Processed character count should have been 43 instead of %u\n", eaten);
940 if (pmk)
941 {
942 IMoniker_IsSystemMoniker(pmk, &moniker_type);
943 ok(moniker_type == MKSYS_CLASSMONIKER, "moniker_type was %d instead of MKSYS_CLASSMONIKER\n", moniker_type);
944 IMoniker_Release(pmk);
945 }
946 hr = IRunningObjectTable_Revoke(pprot, pdwReg1);
947 ok_ole_success(hr, IRunningObjectTable_Revoke);
948 IRunningObjectTable_Release(pprot);
949
950 hr = CreateFileMoniker(wszDisplayNameRunning, &pmk);
951 ok_ole_success(hr, CreateFileMoniker);
952 hr = IBindCtx_GetRunningObjectTable(pbc, &pprot);
953 ok_ole_success(hr, IBindCtx_GetRunningObjectTable);
954 hr = IRunningObjectTable_Register(pprot, 0, (IUnknown *)&Test_ClassFactory, pmk, &pdwReg1);
955 ok_ole_success(hr, IRunningObjectTable_Register);
956 IMoniker_Release(pmk);
957 pmk = NULL;
958 hr = MkParseDisplayName(pbc, wszDisplayNameRunning, &eaten, &pmk);
959 ok_ole_success(hr, MkParseDisplayName);
960 ok(eaten == sizeof(wszDisplayNameRunning)/sizeof(WCHAR) - 1,
961 "Processed character count should have been 15 instead of %u\n", eaten);
962 if (pmk)
963 {
964 IMoniker_IsSystemMoniker(pmk, &moniker_type);
965 ok(moniker_type == MKSYS_FILEMONIKER, "moniker_type was %d instead of MKSYS_FILEMONIKER\n", moniker_type);
966 IMoniker_Release(pmk);
967 }
968 hr = IRunningObjectTable_Revoke(pprot, pdwReg1);
969 ok_ole_success(hr, IRunningObjectTable_Revoke);
970 IRunningObjectTable_Release(pprot);
971
972 hr = CoRegisterClassObject(&CLSID_StdFont, (IUnknown *)&ParseDisplayName, CLSCTX_INPROC_SERVER, REGCLS_MULTI_SEPARATE, &pdwReg1);
973 ok_ole_success(hr, CoRegisterClassObject);
974
975 expected_display_name = wszDisplayNameProgId1;
976 hr = MkParseDisplayName(pbc, wszDisplayNameProgId1, &eaten, &pmk);
977 ok_ole_success(hr, MkParseDisplayName);
978 ok(eaten == sizeof(wszDisplayNameProgId1)/sizeof(WCHAR) - 1,
979 "Processed character count should have been 8 instead of %u\n", eaten);
980 if (pmk)
981 {
982 IMoniker_IsSystemMoniker(pmk, &moniker_type);
983 ok(moniker_type == MKSYS_ANTIMONIKER, "moniker_type was %d instead of MKSYS_ANTIMONIKER\n", moniker_type);
984 IMoniker_Release(pmk);
985 }
986
987 expected_display_name = wszDisplayNameProgId2;
988 hr = MkParseDisplayName(pbc, wszDisplayNameProgId2, &eaten, &pmk);
989 ok_ole_success(hr, MkParseDisplayName);
990 ok(eaten == sizeof(wszDisplayNameProgId2)/sizeof(WCHAR) - 1,
991 "Processed character count should have been 8 instead of %u\n", eaten);
992 if (pmk)
993 {
994 IMoniker_IsSystemMoniker(pmk, &moniker_type);
995 ok(moniker_type == MKSYS_ANTIMONIKER, "moniker_type was %d instead of MKSYS_ANTIMONIKER\n", moniker_type);
996 IMoniker_Release(pmk);
997 }
998
999 eaten = 0xdeadbeef;
1000 pmk = (IMoniker *)0xdeadbeef;
1001 hr = MkParseDisplayName(pbc, wszDisplayNameProgIdFail, &eaten, &pmk);
1002 ok(hr == MK_E_SYNTAX || hr == MK_E_CANTOPENFILE /* Win9x */,
1003 "MkParseDisplayName with ProgId without marker should fail with MK_E_SYNTAX or MK_E_CANTOPENFILE instead of 0x%08x\n", hr);
1004 ok(eaten == 0, "Processed character count should have been 0 instead of %u\n", eaten);
1005 ok(pmk == NULL, "Output moniker pointer should have been NULL instead of %p\n", pmk);
1006
1007 hr = CoRevokeClassObject(pdwReg1);
1008 ok_ole_success(hr, CoRevokeClassObject);
1009
1010 GetSystemDirectoryA(szDisplayNameFile, sizeof(szDisplayNameFile));
1011 strcat(szDisplayNameFile, "\\kernel32.dll");
1012 len = MultiByteToWideChar(CP_ACP, 0, szDisplayNameFile, -1, wszDisplayNameFile, sizeof(wszDisplayNameFile)/sizeof(wszDisplayNameFile[0]));
1013 hr = MkParseDisplayName(pbc, wszDisplayNameFile, &eaten, &pmk);
1014 ok_ole_success(hr, MkParseDisplayName);
1015 ok(eaten == len - 1, "Processed character count should have been %d instead of %u\n", len - 1, eaten);
1016 if (pmk)
1017 {
1018 IMoniker_IsSystemMoniker(pmk, &moniker_type);
1019 ok(moniker_type == MKSYS_FILEMONIKER, "moniker_type was %d instead of MKSYS_FILEMONIKER\n", moniker_type);
1020 IMoniker_Release(pmk);
1021 }
1022
1023 hr = MkParseDisplayName(pbc, wszDisplayName, &eaten, &pmk);
1024 ok_ole_success(hr, MkParseDisplayName);
1025 ok(eaten == sizeof(wszDisplayName)/sizeof(WCHAR) - 1, "Processed character count should have been 43 instead of %u\n", eaten);
1026
1027 if (pmk)
1028 {
1029 hr = IMoniker_BindToObject(pmk, pbc, NULL, &IID_IUnknown, (LPVOID*)&object);
1030 ok_ole_success(hr, IMoniker_BindToObject);
1031
1032 if (SUCCEEDED(hr))
1033 IUnknown_Release(object);
1034 IMoniker_Release(pmk);
1035 }
1036 IBindCtx_Release(pbc);
1037
1038 /* Test the EnumMoniker interface */
1039 hr = CreateBindCtx(0, &pbc);
1040 ok_ole_success(hr, CreateBindCtx);
1041
1042 hr = CreateFileMoniker(wszFileName1, &pmk1);
1043 ok(hr==0, "CreateFileMoniker for file hr=%08x\n", hr);
1044 hr = CreateFileMoniker(wszFileName2, &pmk2);
1045 ok(hr==0, "CreateFileMoniker for file hr=%08x\n", hr);
1046 hr = IBindCtx_GetRunningObjectTable(pbc, &pprot);
1047 ok(hr==0, "IBindCtx_GetRunningObjectTable hr=%08x\n", hr);
1048
1049 /* Check EnumMoniker before registering */
1050 hr = IRunningObjectTable_EnumRunning(pprot, &spEM1);
1051 ok(hr==0, "IRunningObjectTable_EnumRunning hr=%08x\n", hr);
1052 hr = IEnumMoniker_QueryInterface(spEM1, &IID_IUnknown, (void*) &lpEM1);
1053 /* Register a couple of Monikers and check is ok */
1054 ok(hr==0, "IEnumMoniker_QueryInterface hr %08x %p\n", hr, lpEM1);
1055
1056 matchCnt = count_moniker_matches(pbc, spEM1);
1057 trace("Number of matches is %i\n", matchCnt);
1058
1059 grflags= grflags | ROTFLAGS_REGISTRATIONKEEPSALIVE;
1060 hr = IRunningObjectTable_Register(pprot, grflags, lpEM1, pmk1, &pdwReg1);
1061 ok(hr==0, "IRunningObjectTable_Register hr=%08x %p %08x %p %p %d\n",
1062 hr, pprot, grflags, lpEM1, pmk1, pdwReg1);
1063
1064 trace("IROT::Register\n");
1065 grflags=0;
1066 grflags= grflags | ROTFLAGS_REGISTRATIONKEEPSALIVE;
1067 hr = IRunningObjectTable_Register(pprot, grflags, lpEM1, pmk2, &pdwReg2);
1068 ok(hr==0, "IRunningObjectTable_Register hr=%08x %p %08x %p %p %d\n", hr,
1069 pprot, grflags, lpEM1, pmk2, pdwReg2);
1070
1071 hr = IRunningObjectTable_EnumRunning(pprot, &spEM2);
1072 ok(hr==0, "IRunningObjectTable_EnumRunning hr=%08x\n", hr);
1073
1074 matchCnt = count_moniker_matches(pbc, spEM2);
1075 ok(matchCnt==2, "Number of matches should be equal to 2 not %i\n", matchCnt);
1076
1077 trace("IEnumMoniker::Clone\n");
1078 IEnumMoniker_Clone(spEM2, &spEM3);
1079
1080 matchCnt = count_moniker_matches(pbc, spEM3);
1081 ok(matchCnt==0, "Number of matches should be equal to 0 not %i\n", matchCnt);
1082 trace("IEnumMoniker::Reset\n");
1083 IEnumMoniker_Reset(spEM3);
1084
1085 matchCnt = count_moniker_matches(pbc, spEM3);
1086 ok(matchCnt==2, "Number of matches should be equal to 2 not %i\n", matchCnt);
1087
1088 IRunningObjectTable_Revoke(pprot,pdwReg1);
1089 IRunningObjectTable_Revoke(pprot,pdwReg2);
1090 IUnknown_Release(lpEM1);
1091 IEnumMoniker_Release(spEM1);
1092 IEnumMoniker_Release(spEM2);
1093 IEnumMoniker_Release(spEM3);
1094 IMoniker_Release(pmk1);
1095 IMoniker_Release(pmk2);
1096 IRunningObjectTable_Release(pprot);
1097
1098 IBindCtx_Release(pbc);
1099 }
1100
1101 static const LARGE_INTEGER llZero;
1102
1103 static const BYTE expected_class_moniker_marshal_data[] =
1104 {
1105 0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
1106 0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1107 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1108 0x1a,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
1109 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1110 0x00,0x00,0x00,0x00,0x14,0x00,0x00,0x00,
1111 0x05,0xe0,0x02,0x00,0x00,0x00,0x00,0x00,
1112 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1113 0x00,0x00,0x00,0x00,
1114 };
1115
1116 static const BYTE expected_class_moniker_saved_data[] =
1117 {
1118 0x05,0xe0,0x02,0x00,0x00,0x00,0x00,0x00,
1119 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1120 0x00,0x00,0x00,0x00,
1121 };
1122
1123 static const BYTE expected_class_moniker_comparison_data[] =
1124 {
1125 0x1a,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
1126 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1127 0x05,0xe0,0x02,0x00,0x00,0x00,0x00,0x00,
1128 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1129 };
1130
1131 static const WCHAR expected_class_moniker_display_name[] =
1132 {
1133 'c','l','s','i','d',':','0','0','0','2','E','0','0','5','-','0','0','0',
1134 '0','-','0','0','0','0','-','C','0','0','0','-','0','0','0','0','0','0',
1135 '0','0','0','0','4','6',':',0
1136 };
1137
1138 static const BYTE expected_item_moniker_comparison_data[] =
1139 {
1140 0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
1141 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1142 0x21,0x00,0x54,0x00,0x45,0x00,0x53,0x00,
1143 0x54,0x00,0x00,0x00,
1144 };
1145
1146 static const BYTE expected_item_moniker_saved_data[] =
1147 {
1148 0x02,0x00,0x00,0x00,0x21,0x00,0x05,0x00,
1149 0x00,0x00,0x54,0x65,0x73,0x74,0x00,
1150 };
1151
1152 static const BYTE expected_item_moniker_marshal_data[] =
1153 {
1154 0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
1155 0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1156 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1157 0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
1158 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1159 0x00,0x00,0x00,0x00,0x36,0x00,0x00,0x00,
1160 0x02,0x00,0x00,0x00,0x21,0x00,0x05,0x00,
1161 0x00,0x00,0x54,0x65,0x73,0x74,0x00,
1162 };
1163
1164 static const BYTE expected_anti_moniker_marshal_data[] =
1165 {
1166 0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
1167 0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1168 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1169 0x05,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
1170 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1171 0x00,0x00,0x00,0x00,0x14,0x00,0x00,0x00,
1172 0x01,0x00,0x00,0x00,
1173 };
1174
1175 static const BYTE expected_anti_moniker_saved_data[] =
1176 {
1177 0x01,0x00,0x00,0x00,
1178 };
1179
1180 static const BYTE expected_anti_moniker_comparison_data[] =
1181 {
1182 0x05,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
1183 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1184 0x01,0x00,0x00,0x00,
1185 };
1186
1187 static const BYTE expected_gc_moniker_marshal_data[] =
1188 {
1189 0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
1190 0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1191 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1192 0x09,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
1193 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1194 0x00,0x00,0x00,0x00,0x2c,0x01,0x00,0x00,
1195 0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
1196 0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1197 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1198 0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
1199 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1200 0x00,0x00,0x00,0x00,0x36,0x00,0x00,0x00,
1201 0x02,0x00,0x00,0x00,0x21,0x00,0x05,0x00,
1202 0x00,0x00,0x54,0x65,0x73,0x74,0x00,0x4d,
1203 0x45,0x4f,0x57,0x04,0x00,0x00,0x00,0x0f,
1204 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xc0,
1205 0x00,0x00,0x00,0x00,0x00,0x00,0x46,0x04,
1206 0x03,0x00,0x00,0x00,0x00,0x00,0x00,0xc0,
1207 0x00,0x00,0x00,0x00,0x00,0x00,0x46,0x00,
1208 0x00,0x00,0x00,0x36,0x00,0x00,0x00,0x02,
1209 0x00,0x00,0x00,0x23,0x00,0x05,0x00,0x00,
1210 0x00,0x57,0x69,0x6e,0x65,0x00,
1211 };
1212
1213 static const BYTE expected_gc_moniker_saved_data[] =
1214 {
1215 0x02,0x00,0x00,0x00,0x04,0x03,0x00,0x00,
1216 0x00,0x00,0x00,0x00,0xc0,0x00,0x00,0x00,
1217 0x00,0x00,0x00,0x46,0x02,0x00,0x00,0x00,
1218 0x21,0x00,0x05,0x00,0x00,0x00,0x54,0x65,
1219 0x73,0x74,0x00,0x04,0x03,0x00,0x00,0x00,
1220 0x00,0x00,0x00,0xc0,0x00,0x00,0x00,0x00,
1221 0x00,0x00,0x46,0x02,0x00,0x00,0x00,0x23,
1222 0x00,0x05,0x00,0x00,0x00,0x57,0x69,0x6e,
1223 0x65,0x00,
1224 };
1225
1226 static const BYTE expected_gc_moniker_comparison_data[] =
1227 {
1228 0x09,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
1229 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1230 0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
1231 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
1232 0x21,0x00,0x54,0x00,0x45,0x00,0x53,0x00,
1233 0x54,0x00,0x00,0x00,0x04,0x03,0x00,0x00,
1234 0x00,0x00,0x00,0x00,0xc0,0x00,0x00,0x00,
1235 0x00,0x00,0x00,0x46,0x23,0x00,0x57,0x00,
1236 0x49,0x00,0x4e,0x00,0x45,0x00,0x00,0x00,
1237 };
1238
1239 static void test_moniker(
1240 const char *testname, IMoniker *moniker,
1241 const BYTE *expected_moniker_marshal_data, unsigned int sizeof_expected_moniker_marshal_data,
1242 const BYTE *expected_moniker_saved_data, unsigned int sizeof_expected_moniker_saved_data,
1243 const BYTE *expected_moniker_comparison_data, unsigned int sizeof_expected_moniker_comparison_data,
1244 LPCWSTR expected_display_name)
1245 {
1246 IStream * stream;
1247 IROTData * rotdata;
1248 HRESULT hr;
1249 HGLOBAL hglobal;
1250 LPBYTE moniker_data;
1251 DWORD moniker_size;
1252 DWORD i;
1253 BOOL same;
1254 BYTE buffer[128];
1255 IMoniker * moniker_proxy;
1256 LPOLESTR display_name;
1257 IBindCtx *bindctx;
1258
1259 hr = IMoniker_IsDirty(moniker);
1260 ok(hr == S_FALSE, "%s: IMoniker_IsDirty should return S_FALSE, not 0x%08x\n", testname, hr);
1261
1262 /* Display Name */
1263
1264 hr = CreateBindCtx(0, &bindctx);
1265 ok_ole_success(hr, CreateBindCtx);
1266
1267 hr = IMoniker_GetDisplayName(moniker, bindctx, NULL, &display_name);
1268 ok_ole_success(hr, IMoniker_GetDisplayName);
1269 ok(!lstrcmpW(display_name, expected_display_name), "%s: display name wasn't what was expected\n", testname);
1270
1271 CoTaskMemFree(display_name);
1272 IBindCtx_Release(bindctx);
1273
1274 hr = IMoniker_IsDirty(moniker);
1275 ok(hr == S_FALSE, "%s: IMoniker_IsDirty should return S_FALSE, not 0x%08x\n", testname, hr);
1276
1277 /* IROTData::GetComparisonData test */
1278
1279 hr = IMoniker_QueryInterface(moniker, &IID_IROTData, (void **)&rotdata);
1280 ok_ole_success(hr, IMoniker_QueryInterface_IID_IROTData);
1281
1282 hr = IROTData_GetComparisonData(rotdata, buffer, sizeof(buffer), &moniker_size);
1283 ok_ole_success(hr, IROTData_GetComparisonData);
1284
1285 if (hr != S_OK) moniker_size = 0;
1286
1287 /* first check we have the right amount of data */
1288 ok(moniker_size == sizeof_expected_moniker_comparison_data,
1289 "%s: Size of comparison data differs (expected %d, actual %d)\n",
1290 testname, sizeof_expected_moniker_comparison_data, moniker_size);
1291
1292 /* then do a byte-by-byte comparison */
1293 same = TRUE;
1294 for (i = 0; i < min(moniker_size, sizeof_expected_moniker_comparison_data); i++)
1295 {
1296 if (expected_moniker_comparison_data[i] != buffer[i])
1297 {
1298 same = FALSE;
1299 break;
1300 }
1301 }
1302
1303 ok(same, "%s: Comparison data differs\n", testname);
1304 if (!same)
1305 {
1306 for (i = 0; i < moniker_size; i++)
1307 {
1308 if (i % 8 == 0) printf(" ");
1309 printf("0x%02x,", buffer[i]);
1310 if (i % 8 == 7) printf("\n");
1311 }
1312 printf("\n");
1313 }
1314
1315 IROTData_Release(rotdata);
1316
1317 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
1318 ok_ole_success(hr, CreateStreamOnHGlobal);
1319
1320 /* Saving */
1321
1322 hr = IMoniker_Save(moniker, stream, TRUE);
1323 ok_ole_success(hr, IMoniker_Save);
1324
1325 hr = GetHGlobalFromStream(stream, &hglobal);
1326 ok_ole_success(hr, GetHGlobalFromStream);
1327
1328 moniker_size = GlobalSize(hglobal);
1329
1330 moniker_data = GlobalLock(hglobal);
1331
1332 /* first check we have the right amount of data */
1333 ok(moniker_size == round_global_size(sizeof_expected_moniker_saved_data),
1334 "%s: Size of saved data differs (expected %d, actual %d)\n",
1335 testname, (DWORD)round_global_size(sizeof_expected_moniker_saved_data), moniker_size);
1336
1337 /* then do a byte-by-byte comparison */
1338 same = TRUE;
1339 for (i = 0; i < min(moniker_size, round_global_size(sizeof_expected_moniker_saved_data)); i++)
1340 {
1341 if (expected_moniker_saved_data[i] != moniker_data[i])
1342 {
1343 same = FALSE;
1344 break;
1345 }
1346 }
1347
1348 ok(same, "%s: Saved data differs\n", testname);
1349 if (!same)
1350 {
1351 for (i = 0; i < moniker_size; i++)
1352 {
1353 if (i % 8 == 0) printf(" ");
1354 printf("0x%02x,", moniker_data[i]);
1355 if (i % 8 == 7) printf("\n");
1356 }
1357 printf("\n");
1358 }
1359
1360 GlobalUnlock(hglobal);
1361
1362 IStream_Release(stream);
1363
1364 /* Marshaling tests */
1365
1366 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
1367 ok_ole_success(hr, CreateStreamOnHGlobal);
1368
1369 hr = CoMarshalInterface(stream, &IID_IMoniker, (IUnknown *)moniker, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1370 ok_ole_success(hr, CoMarshalInterface);
1371
1372 hr = GetHGlobalFromStream(stream, &hglobal);
1373 ok_ole_success(hr, GetHGlobalFromStream);
1374
1375 moniker_size = GlobalSize(hglobal);
1376
1377 moniker_data = GlobalLock(hglobal);
1378
1379 /* first check we have the right amount of data */
1380 ok(moniker_size == round_global_size(sizeof_expected_moniker_marshal_data),
1381 "%s: Size of marshaled data differs (expected %d, actual %d)\n",
1382 testname, (DWORD)round_global_size(sizeof_expected_moniker_marshal_data), moniker_size);
1383
1384 /* then do a byte-by-byte comparison */
1385 same = TRUE;
1386 if (expected_moniker_marshal_data)
1387 {
1388 for (i = 0; i < min(moniker_size, round_global_size(sizeof_expected_moniker_marshal_data)); i++)
1389 {
1390 if (expected_moniker_marshal_data[i] != moniker_data[i])
1391 {
1392 same = FALSE;
1393 break;
1394 }
1395 }
1396 }
1397
1398 ok(same, "%s: Marshaled data differs\n", testname);
1399 if (!same)
1400 {
1401 for (i = 0; i < moniker_size; i++)
1402 {
1403 if (i % 8 == 0) printf(" ");
1404 printf("0x%02x,", moniker_data[i]);
1405 if (i % 8 == 7) printf("\n");
1406 }
1407 printf("\n");
1408 }
1409
1410 GlobalUnlock(hglobal);
1411
1412 IStream_Seek(stream, llZero, STREAM_SEEK_SET, NULL);
1413 hr = CoUnmarshalInterface(stream, &IID_IMoniker, (void **)&moniker_proxy);
1414 ok_ole_success(hr, CoUnmarshalInterface);
1415
1416 IStream_Release(stream);
1417 IMoniker_Release(moniker_proxy);
1418 }
1419
1420 static void test_class_moniker(void)
1421 {
1422 HRESULT hr;
1423 IMoniker *moniker;
1424 DWORD moniker_type;
1425 DWORD hash;
1426 IBindCtx *bindctx;
1427 IMoniker *inverse;
1428 IUnknown *unknown;
1429 FILETIME filetime;
1430
1431 hr = CreateClassMoniker(&CLSID_StdComponentCategoriesMgr, &moniker);
1432 ok_ole_success(hr, CreateClassMoniker);
1433 if (!moniker) return;
1434
1435 test_moniker("class moniker", moniker,
1436 expected_class_moniker_marshal_data, sizeof(expected_class_moniker_marshal_data),
1437 expected_class_moniker_saved_data, sizeof(expected_class_moniker_saved_data),
1438 expected_class_moniker_comparison_data, sizeof(expected_class_moniker_comparison_data),
1439 expected_class_moniker_display_name);
1440
1441 /* Hashing */
1442
1443 hr = IMoniker_Hash(moniker, &hash);
1444 ok_ole_success(hr, IMoniker_Hash);
1445
1446 ok(hash == CLSID_StdComponentCategoriesMgr.Data1,
1447 "Hash value != Data1 field of clsid, instead was 0x%08x\n",
1448 hash);
1449
1450 /* IsSystemMoniker test */
1451
1452 hr = IMoniker_IsSystemMoniker(moniker, &moniker_type);
1453 ok_ole_success(hr, IMoniker_IsSystemMoniker);
1454
1455 ok(moniker_type == MKSYS_CLASSMONIKER,
1456 "dwMkSys != MKSYS_CLASSMONIKER, instead was 0x%08x\n",
1457 moniker_type);
1458
1459 hr = CreateBindCtx(0, &bindctx);
1460 ok_ole_success(hr, CreateBindCtx);
1461
1462 /* IsRunning test */
1463 hr = IMoniker_IsRunning(moniker, NULL, NULL, NULL);
1464 ok(hr == E_NOTIMPL, "IMoniker_IsRunning should return E_NOTIMPL, not 0x%08x\n", hr);
1465
1466 hr = IMoniker_IsRunning(moniker, bindctx, NULL, NULL);
1467 ok(hr == E_NOTIMPL, "IMoniker_IsRunning should return E_NOTIMPL, not 0x%08x\n", hr);
1468
1469 hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, &filetime);
1470 ok(hr == MK_E_UNAVAILABLE, "IMoniker_GetTimeOfLastChange should return MK_E_UNAVAILABLE, not 0x%08x\n", hr);
1471
1472 hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
1473 ok_ole_success(hr, IMoniker_BindToObject);
1474 IUnknown_Release(unknown);
1475
1476 hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
1477 ok_ole_success(hr, IMoniker_BindToStorage);
1478 IUnknown_Release(unknown);
1479
1480 IBindCtx_Release(bindctx);
1481
1482 hr = IMoniker_Inverse(moniker, &inverse);
1483 ok_ole_success(hr, IMoniker_Inverse);
1484 IMoniker_Release(inverse);
1485
1486 IMoniker_Release(moniker);
1487 }
1488
1489 static void test_file_moniker(WCHAR* path)
1490 {
1491 IStream *stream;
1492 IMoniker *moniker1 = NULL, *moniker2 = NULL;
1493 HRESULT hr;
1494
1495 hr = CreateFileMoniker(path, &moniker1);
1496 ok_ole_success(hr, CreateFileMoniker);
1497
1498 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
1499 ok_ole_success(hr, CreateStreamOnHGlobal);
1500
1501 /* Marshal */
1502 hr = CoMarshalInterface(stream, &IID_IMoniker, (IUnknown *)moniker1, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1503 ok_ole_success(hr, CoMarshalInterface);
1504
1505 /* Rewind */
1506 hr = IStream_Seek(stream, llZero, STREAM_SEEK_SET, NULL);
1507 ok_ole_success(hr, IStream_Seek);
1508
1509 /* Unmarshal */
1510 hr = CoUnmarshalInterface(stream, &IID_IMoniker, (void**)&moniker2);
1511 ok_ole_success(hr, CoUnmarshalInterface);
1512
1513 hr = IMoniker_IsEqual(moniker1, moniker2);
1514 ok_ole_success(hr, IsEqual);
1515
1516 IStream_Release(stream);
1517 if (moniker1)
1518 IMoniker_Release(moniker1);
1519 if (moniker2)
1520 IMoniker_Release(moniker2);
1521 }
1522
1523 static void test_file_monikers(void)
1524 {
1525 static WCHAR wszFile[][30] = {
1526 {'\\', 'w','i','n','d','o','w','s','\\','s','y','s','t','e','m','\\','t','e','s','t','1','.','d','o','c',0},
1527 {'\\', 'a','b','c','d','e','f','g','\\','h','i','j','k','l','\\','m','n','o','p','q','r','s','t','u','.','m','n','o',0},
1528 /* These map to themselves in Windows-1252 & 932 (Shift-JIS) */
1529 {0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0},
1530 /* U+2020 = DAGGER = 0x86 (1252) = 0x813f (932)
1531 * U+20AC = EURO SIGN = 0x80 (1252) = undef (932)
1532 * U+0100 .. = Latin extended-A
1533 */
1534 {0x20ac, 0x2020, 0x100, 0x101, 0x102, 0x103, 0x104, 0x105, 0x106, 0x107, 0x108, 0x109, 0x10a, 0x10b, 0x10c, 0},
1535 };
1536
1537 int i;
1538
1539 trace("ACP is %u\n", GetACP());
1540
1541 for (i = 0; i < COUNTOF(wszFile); ++i)
1542 {
1543 int j ;
1544 if (i == 2)
1545 {
1546 BOOL used;
1547 WideCharToMultiByte( CP_ACP, WC_NO_BEST_FIT_CHARS, wszFile[i], -1, NULL, 0, NULL, &used );
1548 if (used)
1549 {
1550 skip("string 2 doesn't round trip in codepage %u\n", GetACP() );
1551 continue;
1552 }
1553 }
1554 for (j = lstrlenW(wszFile[i]); j > 0; --j)
1555 {
1556 wszFile[i][j] = 0;
1557 test_file_moniker(wszFile[i]);
1558 }
1559 }
1560 }
1561
1562 static void test_item_moniker(void)
1563 {
1564 HRESULT hr;
1565 IMoniker *moniker;
1566 DWORD moniker_type;
1567 DWORD hash;
1568 IBindCtx *bindctx;
1569 IMoniker *inverse;
1570 IUnknown *unknown;
1571 static const WCHAR wszDelimiter[] = {'!',0};
1572 static const WCHAR wszObjectName[] = {'T','e','s','t',0};
1573 static const WCHAR expected_display_name[] = { '!','T','e','s','t',0 };
1574
1575 hr = CreateItemMoniker(wszDelimiter, wszObjectName, &moniker);
1576 ok_ole_success(hr, CreateItemMoniker);
1577
1578 test_moniker("item moniker", moniker,
1579 expected_item_moniker_marshal_data, sizeof(expected_item_moniker_marshal_data),
1580 expected_item_moniker_saved_data, sizeof(expected_item_moniker_saved_data),
1581 expected_item_moniker_comparison_data, sizeof(expected_item_moniker_comparison_data),
1582 expected_display_name);
1583
1584 /* Hashing */
1585
1586 hr = IMoniker_Hash(moniker, &hash);
1587 ok_ole_success(hr, IMoniker_Hash);
1588
1589 ok(hash == 0x73c,
1590 "Hash value != 0x73c, instead was 0x%08x\n",
1591 hash);
1592
1593 /* IsSystemMoniker test */
1594
1595 hr = IMoniker_IsSystemMoniker(moniker, &moniker_type);
1596 ok_ole_success(hr, IMoniker_IsSystemMoniker);
1597
1598 ok(moniker_type == MKSYS_ITEMMONIKER,
1599 "dwMkSys != MKSYS_ITEMMONIKER, instead was 0x%08x\n",
1600 moniker_type);
1601
1602 hr = CreateBindCtx(0, &bindctx);
1603 ok_ole_success(hr, CreateBindCtx);
1604
1605 /* IsRunning test */
1606 hr = IMoniker_IsRunning(moniker, NULL, NULL, NULL);
1607 ok(hr == E_INVALIDARG, "IMoniker_IsRunning should return E_INVALIDARG, not 0x%08x\n", hr);
1608
1609 hr = IMoniker_IsRunning(moniker, bindctx, NULL, NULL);
1610 ok(hr == S_FALSE, "IMoniker_IsRunning should return S_FALSE, not 0x%08x\n", hr);
1611
1612 hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
1613 ok(hr == E_INVALIDARG, "IMoniker_BindToStorage should return E_INVALIDARG, not 0x%08x\n", hr);
1614
1615 hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
1616 ok(hr == E_INVALIDARG, "IMoniker_BindToObject should return E_INVALIDARG, not 0x%08x\n", hr);
1617
1618 IBindCtx_Release(bindctx);
1619
1620 hr = IMoniker_Inverse(moniker, &inverse);
1621 ok_ole_success(hr, IMoniker_Inverse);
1622 IMoniker_Release(inverse);
1623
1624 IMoniker_Release(moniker);
1625 }
1626
1627 static void test_anti_moniker(void)
1628 {
1629 HRESULT hr;
1630 IMoniker *moniker;
1631 DWORD moniker_type;
1632 DWORD hash;
1633 IBindCtx *bindctx;
1634 FILETIME filetime;
1635 IMoniker *inverse;
1636 IUnknown *unknown;
1637 static const WCHAR expected_display_name[] = { '\\','.','.',0 };
1638
1639 hr = CreateAntiMoniker(&moniker);
1640 ok_ole_success(hr, CreateAntiMoniker);
1641 if (!moniker) return;
1642
1643 test_moniker("anti moniker", moniker,
1644 expected_anti_moniker_marshal_data, sizeof(expected_anti_moniker_marshal_data),
1645 expected_anti_moniker_saved_data, sizeof(expected_anti_moniker_saved_data),
1646 expected_anti_moniker_comparison_data, sizeof(expected_anti_moniker_comparison_data),
1647 expected_display_name);
1648
1649 /* Hashing */
1650 hr = IMoniker_Hash(moniker, &hash);
1651 ok_ole_success(hr, IMoniker_Hash);
1652 ok(hash == 0x80000001,
1653 "Hash value != 0x80000001, instead was 0x%08x\n",
1654 hash);
1655
1656 /* IsSystemMoniker test */
1657 hr = IMoniker_IsSystemMoniker(moniker, &moniker_type);
1658 ok_ole_success(hr, IMoniker_IsSystemMoniker);
1659 ok(moniker_type == MKSYS_ANTIMONIKER,
1660 "dwMkSys != MKSYS_ANTIMONIKER, instead was 0x%08x\n",
1661 moniker_type);
1662
1663 hr = IMoniker_Inverse(moniker, &inverse);
1664 ok(hr == MK_E_NOINVERSE, "IMoniker_Inverse should have returned MK_E_NOINVERSE instead of 0x%08x\n", hr);
1665 ok(inverse == NULL, "inverse should have been set to NULL instead of %p\n", inverse);
1666
1667 hr = CreateBindCtx(0, &bindctx);
1668 ok_ole_success(hr, CreateBindCtx);
1669
1670 /* IsRunning test */
1671 hr = IMoniker_IsRunning(moniker, bindctx, NULL, NULL);
1672 ok(hr == S_FALSE, "IMoniker_IsRunning should return S_FALSE, not 0x%08x\n", hr);
1673
1674 hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, &filetime);
1675 ok(hr == E_NOTIMPL, "IMoniker_GetTimeOfLastChange should return E_NOTIMPL, not 0x%08x\n", hr);
1676
1677 hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
1678 ok(hr == E_NOTIMPL, "IMoniker_BindToObject should return E_NOTIMPL, not 0x%08x\n", hr);
1679
1680 hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
1681 ok(hr == E_NOTIMPL, "IMoniker_BindToStorage should return E_NOTIMPL, not 0x%08x\n", hr);
1682
1683 IBindCtx_Release(bindctx);
1684
1685 IMoniker_Release(moniker);
1686 }
1687
1688 static void test_generic_composite_moniker(void)
1689 {
1690 HRESULT hr;
1691 IMoniker *moniker;
1692 IMoniker *moniker1;
1693 IMoniker *moniker2;
1694 DWORD moniker_type;
1695 DWORD hash;
1696 IBindCtx *bindctx;
1697 FILETIME filetime;
1698 IMoniker *inverse;
1699 IUnknown *unknown;
1700 static const WCHAR wszDelimiter1[] = {'!',0};
1701 static const WCHAR wszObjectName1[] = {'T','e','s','t',0};
1702 static const WCHAR wszDelimiter2[] = {'#',0};
1703 static const WCHAR wszObjectName2[] = {'W','i','n','e',0};
1704 static const WCHAR expected_display_name[] = { '!','T','e','s','t','#','W','i','n','e',0 };
1705
1706 hr = CreateItemMoniker(wszDelimiter1, wszObjectName1, &moniker1);
1707 ok_ole_success(hr, CreateItemMoniker);
1708 hr = CreateItemMoniker(wszDelimiter2, wszObjectName2, &moniker2);
1709 ok_ole_success(hr, CreateItemMoniker);
1710 hr = CreateGenericComposite(moniker1, moniker2, &moniker);
1711 ok_ole_success(hr, CreateGenericComposite);
1712
1713 test_moniker("generic composite moniker", moniker,
1714 expected_gc_moniker_marshal_data, sizeof(expected_gc_moniker_marshal_data),
1715 expected_gc_moniker_saved_data, sizeof(expected_gc_moniker_saved_data),
1716 expected_gc_moniker_comparison_data, sizeof(expected_gc_moniker_comparison_data),
1717 expected_display_name);
1718
1719 /* Hashing */
1720
1721 hr = IMoniker_Hash(moniker, &hash);
1722 ok_ole_success(hr, IMoniker_Hash);
1723
1724 ok(hash == 0xd87,
1725 "Hash value != 0xd87, instead was 0x%08x\n",
1726 hash);
1727
1728 /* IsSystemMoniker test */
1729
1730 hr = IMoniker_IsSystemMoniker(moniker, &moniker_type);
1731 ok_ole_success(hr, IMoniker_IsSystemMoniker);
1732
1733 ok(moniker_type == MKSYS_GENERICCOMPOSITE,
1734 "dwMkSys != MKSYS_GENERICCOMPOSITE, instead was 0x%08x\n",
1735 moniker_type);
1736
1737 hr = CreateBindCtx(0, &bindctx);
1738 ok_ole_success(hr, CreateBindCtx);
1739
1740 /* IsRunning test */
1741 hr = IMoniker_IsRunning(moniker, NULL, NULL, NULL);
1742 ok(hr == E_INVALIDARG, "IMoniker_IsRunning should return E_INVALIDARG, not 0x%08x\n", hr);
1743
1744 hr = IMoniker_IsRunning(moniker, bindctx, NULL, NULL);
1745 todo_wine
1746 ok(hr == S_FALSE, "IMoniker_IsRunning should return S_FALSE, not 0x%08x\n", hr);
1747
1748 hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, &filetime);
1749 ok(hr == MK_E_NOTBINDABLE, "IMoniker_GetTimeOfLastChange should return MK_E_NOTBINDABLE, not 0x%08x\n", hr);
1750
1751 hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
1752 todo_wine
1753 ok(hr == E_INVALIDARG, "IMoniker_BindToObject should return E_INVALIDARG, not 0x%08x\n", hr);
1754
1755 hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
1756 ok(hr == E_INVALIDARG, "IMoniker_BindToStorage should return E_INVALIDARG, not 0x%08x\n", hr);
1757
1758 IBindCtx_Release(bindctx);
1759
1760 hr = IMoniker_Inverse(moniker, &inverse);
1761 ok_ole_success(hr, IMoniker_Inverse);
1762 IMoniker_Release(inverse);
1763
1764 IMoniker_Release(moniker);
1765 }
1766
1767 static void test_pointer_moniker(void)
1768 {
1769 HRESULT hr;
1770 IMoniker *moniker;
1771 DWORD moniker_type;
1772 DWORD hash;
1773 IBindCtx *bindctx;
1774 FILETIME filetime;
1775 IMoniker *inverse;
1776 IUnknown *unknown;
1777 IStream *stream;
1778 IROTData *rotdata;
1779 LPOLESTR display_name;
1780
1781 cLocks = 0;
1782
1783 hr = CreatePointerMoniker((IUnknown *)&Test_ClassFactory, NULL);
1784 ok(hr == E_INVALIDARG, "CreatePointerMoniker(x, NULL) should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1785
1786 hr = CreatePointerMoniker((IUnknown *)&Test_ClassFactory, &moniker);
1787 ok_ole_success(hr, CreatePointerMoniker);
1788 if (!moniker) return;
1789
1790 ok_more_than_one_lock();
1791
1792 /* Display Name */
1793
1794 hr = CreateBindCtx(0, &bindctx);
1795 ok_ole_success(hr, CreateBindCtx);
1796
1797 hr = IMoniker_GetDisplayName(moniker, bindctx, NULL, &display_name);
1798 ok(hr == E_NOTIMPL, "IMoniker_GetDisplayName should have returned E_NOTIMPL instead of 0x%08x\n", hr);
1799
1800 IBindCtx_Release(bindctx);
1801
1802 hr = IMoniker_IsDirty(moniker);
1803 ok(hr == S_FALSE, "IMoniker_IsDirty should return S_FALSE, not 0x%08x\n", hr);
1804
1805 /* IROTData::GetComparisonData test */
1806
1807 hr = IMoniker_QueryInterface(moniker, &IID_IROTData, (void **)&rotdata);
1808 ok(hr == E_NOINTERFACE, "IMoniker_QueryInterface(IID_IROTData) should have returned E_NOINTERFACE instead of 0x%08x\n", hr);
1809
1810 /* Saving */
1811
1812 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
1813 ok_ole_success(hr, CreateStreamOnHGlobal);
1814
1815 hr = IMoniker_Save(moniker, stream, TRUE);
1816 ok(hr == E_NOTIMPL, "IMoniker_Save should have returned E_NOTIMPL instead of 0x%08x\n", hr);
1817
1818 IStream_Release(stream);
1819
1820 /* Hashing */
1821 hr = IMoniker_Hash(moniker, &hash);
1822 ok_ole_success(hr, IMoniker_Hash);
1823 ok(hash == PtrToUlong(&Test_ClassFactory),
1824 "Hash value should have been 0x%08x, instead of 0x%08x\n",
1825 PtrToUlong(&Test_ClassFactory), hash);
1826
1827 /* IsSystemMoniker test */
1828 hr = IMoniker_IsSystemMoniker(moniker, &moniker_type);
1829 ok_ole_success(hr, IMoniker_IsSystemMoniker);
1830 ok(moniker_type == MKSYS_POINTERMONIKER,
1831 "dwMkSys != MKSYS_POINTERMONIKER, instead was 0x%08x\n",
1832 moniker_type);
1833
1834 hr = IMoniker_Inverse(moniker, &inverse);
1835 ok_ole_success(hr, IMoniker_Inverse);
1836 IMoniker_Release(inverse);
1837
1838 hr = CreateBindCtx(0, &bindctx);
1839 ok_ole_success(hr, CreateBindCtx);
1840
1841 /* IsRunning test */
1842 hr = IMoniker_IsRunning(moniker, bindctx, NULL, NULL);
1843 ok(hr == S_OK, "IMoniker_IsRunning should return S_OK, not 0x%08x\n", hr);
1844
1845 hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, &filetime);
1846 ok(hr == E_NOTIMPL, "IMoniker_GetTimeOfLastChange should return E_NOTIMPL, not 0x%08x\n", hr);
1847
1848 hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
1849 ok_ole_success(hr, IMoniker_BindToObject);
1850 IUnknown_Release(unknown);
1851
1852 hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
1853 ok_ole_success(hr, IMoniker_BindToStorage);
1854 IUnknown_Release(unknown);
1855
1856 IMoniker_Release(moniker);
1857
1858 ok_no_locks();
1859
1860 hr = CreatePointerMoniker(NULL, &moniker);
1861 ok_ole_success(hr, CreatePointerMoniker);
1862
1863 hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
1864 ok(hr == E_UNEXPECTED, "IMoniker_BindToObject should have returned E_UNEXPECTED instead of 0x%08x\n", hr);
1865
1866 hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
1867 ok(hr == E_UNEXPECTED, "IMoniker_BindToStorage should have returned E_UNEXPECTED instead of 0x%08x\n", hr);
1868
1869 IBindCtx_Release(bindctx);
1870
1871 IMoniker_Release(moniker);
1872 }
1873
1874 static void test_bind_context(void)
1875 {
1876 HRESULT hr;
1877 IBindCtx *pBindCtx;
1878 IEnumString *pEnumString;
1879 BIND_OPTS2 bind_opts;
1880 HeapUnknown *unknown;
1881 HeapUnknown *unknown2;
1882 IUnknown *param_obj;
1883 ULONG refs;
1884 static const WCHAR wszParamName[] = {'G','e','m','m','a',0};
1885 static const WCHAR wszNonExistent[] = {'N','o','n','E','x','i','s','t','e','n','t',0};
1886
1887 hr = CreateBindCtx(0, NULL);
1888 ok(hr == E_INVALIDARG, "CreateBindCtx with NULL ppbc should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1889
1890 hr = CreateBindCtx(0xdeadbeef, &pBindCtx);
1891 ok(hr == E_INVALIDARG, "CreateBindCtx with reserved value non-zero should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1892
1893 hr = CreateBindCtx(0, &pBindCtx);
1894 ok_ole_success(hr, "CreateBindCtx");
1895
1896 bind_opts.cbStruct = -1;
1897 hr = IBindCtx_GetBindOptions(pBindCtx, (BIND_OPTS *)&bind_opts);
1898 ok_ole_success(hr, "IBindCtx_GetBindOptions");
1899 ok(bind_opts.cbStruct == sizeof(bind_opts) ||
1900 bind_opts.cbStruct == sizeof(bind_opts) + sizeof(void*), /* Vista */
1901 "bind_opts.cbStruct was %d\n", bind_opts.cbStruct);
1902
1903 bind_opts.cbStruct = sizeof(BIND_OPTS);
1904 hr = IBindCtx_GetBindOptions(pBindCtx, (BIND_OPTS *)&bind_opts);
1905 ok_ole_success(hr, "IBindCtx_GetBindOptions");
1906 ok(bind_opts.cbStruct == sizeof(BIND_OPTS), "bind_opts.cbStruct was %d\n", bind_opts.cbStruct);
1907
1908 bind_opts.cbStruct = sizeof(bind_opts);
1909 hr = IBindCtx_GetBindOptions(pBindCtx, (BIND_OPTS *)&bind_opts);
1910 ok_ole_success(hr, "IBindCtx_GetBindOptions");
1911 ok(bind_opts.cbStruct == sizeof(bind_opts), "bind_opts.cbStruct was %d\n", bind_opts.cbStruct);
1912 ok(bind_opts.grfFlags == 0, "bind_opts.grfFlags was 0x%x instead of 0\n", bind_opts.grfFlags);
1913 ok(bind_opts.grfMode == STGM_READWRITE, "bind_opts.grfMode was 0x%x instead of STGM_READWRITE\n", bind_opts.grfMode);
1914 ok(bind_opts.dwTickCountDeadline == 0, "bind_opts.dwTickCountDeadline was %d instead of 0\n", bind_opts.dwTickCountDeadline);
1915 ok(bind_opts.dwTrackFlags == 0, "bind_opts.dwTrackFlags was 0x%x instead of 0\n", bind_opts.dwTrackFlags);
1916 ok(bind_opts.dwClassContext == (CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER|CLSCTX_REMOTE_SERVER),
1917 "bind_opts.dwClassContext should have been 0x15 instead of 0x%x\n", bind_opts.dwClassContext);
1918 ok(bind_opts.locale == GetThreadLocale(), "bind_opts.locale should have been 0x%x instead of 0x%x\n", GetThreadLocale(), bind_opts.locale);
1919 ok(bind_opts.pServerInfo == NULL, "bind_opts.pServerInfo should have been NULL instead of %p\n", bind_opts.pServerInfo);
1920
1921 bind_opts.cbStruct = -1;
1922 hr = IBindCtx_SetBindOptions(pBindCtx, (BIND_OPTS *)&bind_opts);
1923 ok(hr == E_INVALIDARG, "IBindCtx_SetBindOptions with bad cbStruct should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1924
1925 hr = IBindCtx_RegisterObjectParam(pBindCtx, (WCHAR *)wszParamName, NULL);
1926 ok(hr == E_INVALIDARG, "IBindCtx_RegisterObjectParam should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1927
1928 unknown = HeapAlloc(GetProcessHeap(), 0, sizeof(*unknown));
1929 unknown->IUnknown_iface.lpVtbl = &HeapUnknown_Vtbl;
1930 unknown->refs = 1;
1931 hr = IBindCtx_RegisterObjectParam(pBindCtx, (WCHAR *)wszParamName, &unknown->IUnknown_iface);
1932 ok_ole_success(hr, "IBindCtx_RegisterObjectParam");
1933
1934 hr = IBindCtx_GetObjectParam(pBindCtx, (WCHAR *)wszParamName, &param_obj);
1935 ok_ole_success(hr, "IBindCtx_GetObjectParam");
1936 IUnknown_Release(param_obj);
1937
1938 hr = IBindCtx_GetObjectParam(pBindCtx, (WCHAR *)wszNonExistent, &param_obj);
1939 ok(hr == E_FAIL, "IBindCtx_GetObjectParam with nonexistent key should have failed with E_FAIL instead of 0x%08x\n", hr);
1940 ok(param_obj == NULL, "IBindCtx_GetObjectParam with nonexistent key should have set output parameter to NULL instead of %p\n", param_obj);
1941
1942 hr = IBindCtx_RevokeObjectParam(pBindCtx, (WCHAR *)wszNonExistent);
1943 ok(hr == E_FAIL, "IBindCtx_RevokeObjectParam with nonexistent key should have failed with E_FAIL instead of 0x%08x\n", hr);
1944
1945 hr = IBindCtx_EnumObjectParam(pBindCtx, &pEnumString);
1946 ok(hr == E_NOTIMPL, "IBindCtx_EnumObjectParam should have returned E_NOTIMPL instead of 0x%08x\n", hr);
1947 ok(!pEnumString, "pEnumString should be NULL\n");
1948
1949 hr = IBindCtx_RegisterObjectBound(pBindCtx, NULL);
1950 ok_ole_success(hr, "IBindCtx_RegisterObjectBound(NULL)");
1951
1952 hr = IBindCtx_RevokeObjectBound(pBindCtx, NULL);
1953 ok(hr == E_INVALIDARG, "IBindCtx_RevokeObjectBound(NULL) should have return E_INVALIDARG instead of 0x%08x\n", hr);
1954
1955 unknown2 = HeapAlloc(GetProcessHeap(), 0, sizeof(*unknown));
1956 unknown2->IUnknown_iface.lpVtbl = &HeapUnknown_Vtbl;
1957 unknown2->refs = 1;
1958 hr = IBindCtx_RegisterObjectBound(pBindCtx, &unknown2->IUnknown_iface);
1959 ok_ole_success(hr, "IBindCtx_RegisterObjectBound");
1960
1961 hr = IBindCtx_RevokeObjectBound(pBindCtx, &unknown2->IUnknown_iface);
1962 ok_ole_success(hr, "IBindCtx_RevokeObjectBound");
1963
1964 hr = IBindCtx_RevokeObjectBound(pBindCtx, &unknown2->IUnknown_iface);
1965 ok(hr == MK_E_NOTBOUND, "IBindCtx_RevokeObjectBound with not bound object should have returned MK_E_NOTBOUND instead of 0x%08x\n", hr);
1966
1967 IBindCtx_Release(pBindCtx);
1968
1969 refs = IUnknown_Release(&unknown->IUnknown_iface);
1970 ok(!refs, "object param should have been destroyed, instead of having %d refs\n", refs);
1971
1972 refs = IUnknown_Release(&unknown2->IUnknown_iface);
1973 ok(!refs, "bound object should have been destroyed, instead of having %d refs\n", refs);
1974 }
1975
1976 static void test_save_load_filemoniker(void)
1977 {
1978 IMoniker* pMk;
1979 IStream* pStm;
1980 HRESULT hr;
1981 ULARGE_INTEGER size;
1982 LARGE_INTEGER zero_pos, dead_pos, nulls_pos;
1983 DWORD some_val = 0xFEDCBA98;
1984 int i;
1985
1986 /* see FileMonikerImpl_Save docs */
1987 zero_pos.QuadPart = 0;
1988 dead_pos.QuadPart = sizeof(WORD) + sizeof(DWORD) + (lstrlenW(wszFileName1) + 1) + sizeof(WORD);
1989 nulls_pos.QuadPart = dead_pos.QuadPart + sizeof(WORD);
1990
1991 /* create the stream we're going to write to */
1992 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStm);
1993 ok_ole_success(hr, "CreateStreamOnHGlobal");
1994
1995 size.u.LowPart = 128;
1996 hr = IStream_SetSize(pStm, size);
1997 ok_ole_success(hr, "IStream_SetSize");
1998
1999 /* create and save a moniker */
2000 hr = CreateFileMoniker(wszFileName1, &pMk);
2001 ok_ole_success(hr, "CreateFileMoniker");
2002
2003 hr = IMoniker_Save(pMk, pStm, TRUE);
2004 ok_ole_success(hr, "IMoniker_Save");
2005 IMoniker_Release(pMk);
2006
2007 /* overwrite the constants with various values */
2008 hr = IStream_Seek(pStm, zero_pos, STREAM_SEEK_SET, NULL);
2009 ok_ole_success(hr, "IStream_Seek");
2010 hr = IStream_Write(pStm, &some_val, sizeof(WORD), NULL);
2011 ok_ole_success(hr, "IStream_Write");
2012
2013 hr = IStream_Seek(pStm, dead_pos, STREAM_SEEK_SET, NULL);
2014 ok_ole_success(hr, "IStream_Seek");
2015 hr = IStream_Write(pStm, &some_val, sizeof(WORD), NULL);
2016 ok_ole_success(hr, "IStream_Write");
2017
2018 hr = IStream_Seek(pStm, nulls_pos, STREAM_SEEK_SET, NULL);
2019 ok_ole_success(hr, "IStream_Seek");
2020 for(i = 0; i < 5; ++i){
2021 hr = IStream_Write(pStm, &some_val, sizeof(DWORD), NULL);
2022 ok_ole_success(hr, "IStream_Write");
2023 }
2024
2025 /* go back to the start of the stream */
2026 hr = IStream_Seek(pStm, zero_pos, STREAM_SEEK_SET, NULL);
2027 ok_ole_success(hr, "IStream_Seek");
2028
2029 /* create a new moniker and load into it */
2030 hr = CreateFileMoniker(wszFileName1, &pMk);
2031 ok_ole_success(hr, "CreateFileMoniker");
2032
2033 hr = IMoniker_Load(pMk, pStm);
2034 ok_ole_success(hr, "IMoniker_Load");
2035
2036 IMoniker_Release(pMk);
2037 IStream_Release(pStm);
2038 }
2039
2040 START_TEST(moniker)
2041 {
2042 if (!GetProcAddress(GetModuleHandleA("ole32.dll"), "CoRegisterSurrogateEx")) {
2043 win_skip("skipping test on win9x\n");
2044 return;
2045 }
2046
2047 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
2048
2049 test_ROT();
2050 test_ROT_multiple_entries();
2051 test_MkParseDisplayName();
2052 test_class_moniker();
2053 test_file_monikers();
2054 test_item_moniker();
2055 test_anti_moniker();
2056 test_generic_composite_moniker();
2057 test_pointer_moniker();
2058 test_save_load_filemoniker();
2059
2060 /* FIXME: test moniker creation funcs and parsing other moniker formats */
2061
2062 test_bind_context();
2063
2064 CoUninitialize();
2065 }