?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
shlwapi/tests: Fix some test failures on RTL enabled boxes.
[wine/wine-gecko.git] / dlls / shlwapi / tests / ordinal.c
blob7b0203194dd48cf97d21293f69b926b6ffabcd2d
1 /* Unit test suite for SHLWAPI ordinal functions
2 *
3 * Copyright 2004 Jon Griffiths
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #include <stdio.h>
21
22 #define COBJMACROS
23 #include "wine/test.h"
24 #include "winbase.h"
25 #include "winerror.h"
26 #include "winuser.h"
27 #include "ole2.h"
28 #include "oaidl.h"
29 #include "ocidl.h"
30 #include "mlang.h"
31 #include "shlwapi.h"
32 #include "docobj.h"
33 #include "shobjidl.h"
34 #include "shlobj.h"
35
36 /* Function ptrs for ordinal calls */
37 static HMODULE hShlwapi;
38 static BOOL is_win2k_and_lower;
39 static BOOL is_win9x;
40
41 static int (WINAPI *pSHSearchMapInt)(const int*,const int*,int,int);
42 static HRESULT (WINAPI *pGetAcceptLanguagesA)(LPSTR,LPDWORD);
43
44 static HANDLE (WINAPI *pSHAllocShared)(LPCVOID,DWORD,DWORD);
45 static LPVOID (WINAPI *pSHLockShared)(HANDLE,DWORD);
46 static BOOL (WINAPI *pSHUnlockShared)(LPVOID);
47 static BOOL (WINAPI *pSHFreeShared)(HANDLE,DWORD);
48 static HRESULT(WINAPIV *pSHPackDispParams)(DISPPARAMS*,VARIANTARG*,UINT,...);
49 static HRESULT(WINAPI *pIConnectionPoint_SimpleInvoke)(IConnectionPoint*,DISPID,DISPPARAMS*);
50 static HRESULT(WINAPI *pIConnectionPoint_InvokeWithCancel)(IConnectionPoint*,DISPID,DISPPARAMS*,DWORD,DWORD);
51 static HRESULT(WINAPI *pConnectToConnectionPoint)(IUnknown*,REFIID,BOOL,IUnknown*, LPDWORD,IConnectionPoint **);
52 static HRESULT(WINAPI *pSHPropertyBag_ReadLONG)(IPropertyBag *,LPCWSTR,LPLONG);
53 static LONG (WINAPI *pSHSetWindowBits)(HWND, INT, UINT, UINT);
54 static INT (WINAPI *pSHFormatDateTimeA)(const FILETIME UNALIGNED*, DWORD*, LPSTR, UINT);
55 static INT (WINAPI *pSHFormatDateTimeW)(const FILETIME UNALIGNED*, DWORD*, LPWSTR, UINT);
56 static DWORD (WINAPI *pSHGetObjectCompatFlags)(IUnknown*, const CLSID*);
57 static BOOL (WINAPI *pGUIDFromStringA)(LPSTR, CLSID *);
58 static HRESULT (WINAPI *pIUnknown_QueryServiceExec)(IUnknown*, REFIID, const GUID*, DWORD, DWORD, VARIANT*, VARIANT*);
59 static HRESULT (WINAPI *pIUnknown_ProfferService)(IUnknown*, REFGUID, IServiceProvider*, DWORD*);
60 static HWND (WINAPI *pSHCreateWorkerWindowA)(LONG, HWND, DWORD, DWORD, HMENU, LONG_PTR);
61 static HRESULT (WINAPI *pSHIShellFolder_EnumObjects)(LPSHELLFOLDER, HWND, SHCONTF, IEnumIDList**);
62 static DWORD (WINAPI *pSHGetIniStringW)(LPCWSTR, LPCWSTR, LPWSTR, DWORD, LPCWSTR);
63 static BOOL (WINAPI *pSHSetIniStringW)(LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR);
64 static HKEY (WINAPI *pSHGetShellKey)(DWORD, LPWSTR, BOOL);
65
66 static HMODULE hmlang;
67 static HRESULT (WINAPI *pLcidToRfc1766A)(LCID, LPSTR, INT);
68
69 static HMODULE hshell32;
70 static HRESULT (WINAPI *pSHGetDesktopFolder)(IShellFolder**);
71
72 static const CHAR ie_international[] = {
73 'S','o','f','t','w','a','r','e','\\',
74 'M','i','c','r','o','s','o','f','t','\\',
75 'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\',
76 'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
77 static const CHAR acceptlanguage[] = {
78 'A','c','c','e','p','t','L','a','n','g','u','a','g','e',0};
79
80 static int strcmp_wa(LPCWSTR strw, const char *stra)
81 {
82 CHAR buf[512];
83 WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
84 return lstrcmpA(stra, buf);
85 }
86
87 typedef struct {
88 int id;
89 const void *args[5];
90 } call_entry_t;
91
92 typedef struct {
93 call_entry_t *calls;
94 int count;
95 int alloc;
96 } call_trace_t;
97
98 static void init_call_trace(call_trace_t *ctrace)
99 {
100 ctrace->alloc = 10;
101 ctrace->count = 0;
102 ctrace->calls = HeapAlloc(GetProcessHeap(), 0, sizeof(call_entry_t) * ctrace->alloc);
103 }
104
105 static void free_call_trace(const call_trace_t *ctrace)
106 {
107 HeapFree(GetProcessHeap(), 0, ctrace->calls);
108 }
109
110 static void add_call(call_trace_t *ctrace, int id, const void *arg0,
111 const void *arg1, const void *arg2, const void *arg3, const void *arg4)
112 {
113 call_entry_t call;
114
115 call.id = id;
116 call.args[0] = arg0;
117 call.args[1] = arg1;
118 call.args[2] = arg2;
119 call.args[3] = arg3;
120 call.args[4] = arg4;
121
122 if (ctrace->count == ctrace->alloc)
123 {
124 ctrace->alloc *= 2;
125 ctrace->calls = HeapReAlloc(GetProcessHeap(),0, ctrace->calls, ctrace->alloc*sizeof(call_entry_t));
126 }
127
128 ctrace->calls[ctrace->count++] = call;
129 }
130
131 static void ok_trace_(call_trace_t *texpected, call_trace_t *tgot, int line)
132 {
133 if (texpected->count == tgot->count)
134 {
135 INT i;
136 /* compare */
137 for (i = 0; i < texpected->count; i++)
138 {
139 call_entry_t *expected = &texpected->calls[i];
140 call_entry_t *got = &tgot->calls[i];
141 INT j;
142
143 ok_(__FILE__, line)(expected->id == got->id, "got different ids %d: %d, %d\n", i+1, expected->id, got->id);
144
145 for (j = 0; j < 5; j++)
146 {
147 ok_(__FILE__, line)(expected->args[j] == got->args[j], "got different args[%d] for %d: %p, %p\n", j, i+1,
148 expected->args[j], got->args[j]);
149 }
150 }
151 }
152 else
153 ok_(__FILE__, line)(0, "traces length mismatch\n");
154 }
155
156 #define ok_trace(a, b) ok_trace_(a, b, __LINE__)
157
158 /* trace of actually made calls */
159 static call_trace_t trace_got;
160
161 static void test_GetAcceptLanguagesA(void)
162 {
163 static LPCSTR table[] = {"de,en-gb;q=0.7,en;q=0.3",
164 "de,en;q=0.3,en-gb;q=0.7", /* sorting is ignored */
165 "winetest", /* content is ignored */
166 "de-de,de;q=0.5",
167 "de",
168 NULL};
169
170 DWORD exactsize;
171 char original[512];
172 char language[32];
173 char buffer[64];
174 HKEY hroot = NULL;
175 LONG res_query = ERROR_SUCCESS;
176 LONG lres;
177 HRESULT hr;
178 DWORD maxlen = sizeof(buffer) - 2;
179 DWORD len;
180 LCID lcid;
181 LPCSTR entry;
182 INT i = 0;
183
184 if (!pGetAcceptLanguagesA) {
185 win_skip("GetAcceptLanguagesA is not available\n");
186 return;
187 }
188
189 lcid = GetUserDefaultLCID();
190
191 /* Get the original Value */
192 lres = RegOpenKeyA(HKEY_CURRENT_USER, ie_international, &hroot);
193 if (lres) {
194 skip("RegOpenKey(%s) failed: %d\n", ie_international, lres);
195 return;
196 }
197 len = sizeof(original);
198 original[0] = 0;
199 res_query = RegQueryValueExA(hroot, acceptlanguage, 0, NULL, (PBYTE)original, &len);
200
201 RegDeleteValue(hroot, acceptlanguage);
202
203 /* Some windows versions use "lang-COUNTRY" as default */
204 memset(language, 0, sizeof(language));
205 len = GetLocaleInfoA(lcid, LOCALE_SISO639LANGNAME, language, sizeof(language));
206
207 if (len) {
208 lstrcat(language, "-");
209 memset(buffer, 0, sizeof(buffer));
210 len = GetLocaleInfoA(lcid, LOCALE_SISO3166CTRYNAME, buffer, sizeof(buffer) - len - 1);
211 lstrcat(language, buffer);
212 }
213 else
214 {
215 /* LOCALE_SNAME has additional parts in some languages. Try only as last chance */
216 memset(language, 0, sizeof(language));
217 len = GetLocaleInfoA(lcid, LOCALE_SNAME, language, sizeof(language));
218 }
219
220 /* get the default value */
221 len = maxlen;
222 memset(buffer, '#', maxlen);
223 buffer[maxlen] = 0;
224 hr = pGetAcceptLanguagesA( buffer, &len);
225
226 if (hr != S_OK) {
227 win_skip("GetAcceptLanguagesA failed with 0x%x\n", hr);
228 goto restore_original;
229 }
230
231 if (lstrcmpA(buffer, language)) {
232 /* some windows versions use "lang" or "lang-country" as default */
233 language[0] = 0;
234 if (pLcidToRfc1766A) {
235 hr = pLcidToRfc1766A(lcid, language, sizeof(language));
236 ok(hr == S_OK, "LcidToRfc1766A returned 0x%x and %s\n", hr, language);
237 }
238 }
239
240 ok(!lstrcmpA(buffer, language),
241 "have '%s' (searching for '%s')\n", language, buffer);
242
243 if (lstrcmpA(buffer, language)) {
244 win_skip("no more ideas, how to build the default language '%s'\n", buffer);
245 goto restore_original;
246 }
247
248 trace("detected default: %s\n", language);
249 while ((entry = table[i])) {
250
251 exactsize = lstrlenA(entry);
252
253 lres = RegSetValueExA(hroot, acceptlanguage, 0, REG_SZ, (const BYTE *) entry, exactsize + 1);
254 ok(!lres, "got %d for RegSetValueExA: %s\n", lres, entry);
255
256 /* len includes space for the terminating 0 before vista/w2k8 */
257 len = exactsize + 2;
258 memset(buffer, '#', maxlen);
259 buffer[maxlen] = 0;
260 hr = pGetAcceptLanguagesA( buffer, &len);
261 ok(((hr == E_INVALIDARG) && (len == 0)) ||
262 (SUCCEEDED(hr) &&
263 ((len == exactsize) || (len == exactsize+1)) &&
264 !lstrcmpA(buffer, entry)),
265 "+2_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
266
267 len = exactsize + 1;
268 memset(buffer, '#', maxlen);
269 buffer[maxlen] = 0;
270 hr = pGetAcceptLanguagesA( buffer, &len);
271 ok(((hr == E_INVALIDARG) && (len == 0)) ||
272 (SUCCEEDED(hr) &&
273 ((len == exactsize) || (len == exactsize+1)) &&
274 !lstrcmpA(buffer, entry)),
275 "+1_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
276
277 len = exactsize;
278 memset(buffer, '#', maxlen);
279 buffer[maxlen] = 0;
280 hr = pGetAcceptLanguagesA( buffer, &len);
281
282 /* There is no space for the string in the registry.
283 When the buffer is large enough, the default language is returned
284
285 When the buffer is too small for that fallback, win7_32 and w2k8_64
286 and above fail with HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER), but
287 recent os succeed and return a partial result while
288 older os succeed and overflow the buffer */
289
290 ok(((hr == E_INVALIDARG) && (len == 0)) ||
291 (((hr == S_OK) && !lstrcmpA(buffer, language) && (len == lstrlenA(language))) ||
292 ((hr == S_OK) && !memcmp(buffer, language, len)) ||
293 ((hr == __HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)) && !len)),
294 "==_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
295
296 if (exactsize > 1) {
297 len = exactsize - 1;
298 memset(buffer, '#', maxlen);
299 buffer[maxlen] = 0;
300 hr = pGetAcceptLanguagesA( buffer, &len);
301 ok(((hr == E_INVALIDARG) && (len == 0)) ||
302 (((hr == S_OK) && !lstrcmpA(buffer, language) && (len == lstrlenA(language))) ||
303 ((hr == S_OK) && !memcmp(buffer, language, len)) ||
304 ((hr == __HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)) && !len)),
305 "-1_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
306 }
307
308 len = 1;
309 memset(buffer, '#', maxlen);
310 buffer[maxlen] = 0;
311 hr = pGetAcceptLanguagesA( buffer, &len);
312 ok(((hr == E_INVALIDARG) && (len == 0)) ||
313 (((hr == S_OK) && !lstrcmpA(buffer, language) && (len == lstrlenA(language))) ||
314 ((hr == S_OK) && !memcmp(buffer, language, len)) ||
315 ((hr == __HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)) && !len)),
316 "=1_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
317
318 len = maxlen;
319 hr = pGetAcceptLanguagesA( NULL, &len);
320
321 /* w2k3 and below: E_FAIL and untouched len,
322 since w2k8: S_OK and needed size (excluding 0) */
323 ok( ((hr == S_OK) && (len == exactsize)) ||
324 ((hr == E_FAIL) && (len == maxlen)),
325 "NULL,max #%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
326
327 i++;
328 }
329
330 /* without a value in the registry, a default language is returned */
331 RegDeleteValue(hroot, acceptlanguage);
332
333 len = maxlen;
334 memset(buffer, '#', maxlen);
335 buffer[maxlen] = 0;
336 hr = pGetAcceptLanguagesA( buffer, &len);
337 ok( ((hr == S_OK) && (len == lstrlenA(language))),
338 "max: got 0x%x with %d and %s (expected S_OK with %d and '%s'\n",
339 hr, len, buffer, lstrlenA(language), language);
340
341 len = 2;
342 memset(buffer, '#', maxlen);
343 buffer[maxlen] = 0;
344 hr = pGetAcceptLanguagesA( buffer, &len);
345 ok( (((hr == S_OK) || (hr == E_INVALIDARG)) && !memcmp(buffer, language, len)) ||
346 ((hr == __HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)) && !len),
347 "=2: got 0x%x with %d and %s\n", hr, len, buffer);
348
349 len = 1;
350 memset(buffer, '#', maxlen);
351 buffer[maxlen] = 0;
352 hr = pGetAcceptLanguagesA( buffer, &len);
353 /* When the buffer is too small, win7_32 and w2k8_64 and above fail with
354 HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER), other versions suceed
355 and return a partial 0 terminated result while other versions
356 fail with E_INVALIDARG and return a partial unterminated result */
357 ok( (((hr == S_OK) || (hr == E_INVALIDARG)) && !memcmp(buffer, language, len)) ||
358 ((hr == __HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)) && !len),
359 "=1: got 0x%x with %d and %s\n", hr, len, buffer);
360
361 len = 0;
362 memset(buffer, '#', maxlen);
363 buffer[maxlen] = 0;
364 hr = pGetAcceptLanguagesA( buffer, &len);
365 /* w2k3 and below: E_FAIL, since w2k8: E_INVALIDARG */
366 ok((hr == E_FAIL) || (hr == E_INVALIDARG),
367 "got 0x%x (expected E_FAIL or E_INVALIDARG)\n", hr);
368
369 memset(buffer, '#', maxlen);
370 buffer[maxlen] = 0;
371 hr = pGetAcceptLanguagesA( buffer, NULL);
372 /* w2k3 and below: E_FAIL, since w2k8: E_INVALIDARG */
373 ok((hr == E_FAIL) || (hr == E_INVALIDARG),
374 "got 0x%x (expected E_FAIL or E_INVALIDARG)\n", hr);
375
376
377 hr = pGetAcceptLanguagesA( NULL, NULL);
378 /* w2k3 and below: E_FAIL, since w2k8: E_INVALIDARG */
379 ok((hr == E_FAIL) || (hr == E_INVALIDARG),
380 "got 0x%x (expected E_FAIL or E_INVALIDARG)\n", hr);
381
382 restore_original:
383 if (!res_query) {
384 len = lstrlenA(original);
385 lres = RegSetValueExA(hroot, acceptlanguage, 0, REG_SZ, (const BYTE *) original, len ? len + 1: 0);
386 ok(!lres, "RegSetValueEx(%s) failed: %d\n", original, lres);
387 }
388 else
389 {
390 RegDeleteValue(hroot, acceptlanguage);
391 }
392 RegCloseKey(hroot);
393 }
394
395 static void test_SHSearchMapInt(void)
396 {
397 int keys[8], values[8];
398 int i = 0;
399
400 if (!pSHSearchMapInt)
401 return;
402
403 memset(keys, 0, sizeof(keys));
404 memset(values, 0, sizeof(values));
405 keys[0] = 99; values[0] = 101;
406
407 /* NULL key/value lists crash native, so skip testing them */
408
409 /* 1 element */
410 i = pSHSearchMapInt(keys, values, 1, keys[0]);
411 ok(i == values[0], "Len 1, expected %d, got %d\n", values[0], i);
412
413 /* Key doesn't exist */
414 i = pSHSearchMapInt(keys, values, 1, 100);
415 ok(i == -1, "Len 1 - bad key, expected -1, got %d\n", i);
416
417 /* Len = 0 => not found */
418 i = pSHSearchMapInt(keys, values, 0, keys[0]);
419 ok(i == -1, "Len 1 - passed len 0, expected -1, got %d\n", i);
420
421 /* 2 elements, len = 1 */
422 keys[1] = 98; values[1] = 102;
423 i = pSHSearchMapInt(keys, values, 1, keys[1]);
424 ok(i == -1, "Len 1 - array len 2, expected -1, got %d\n", i);
425
426 /* 2 elements, len = 2 */
427 i = pSHSearchMapInt(keys, values, 2, keys[1]);
428 ok(i == values[1], "Len 2, expected %d, got %d\n", values[1], i);
429
430 /* Searches forward */
431 keys[2] = 99; values[2] = 103;
432 i = pSHSearchMapInt(keys, values, 3, keys[0]);
433 ok(i == values[0], "Len 3, expected %d, got %d\n", values[0], i);
434 }
435
436 static void test_alloc_shared(void)
437 {
438 DWORD procid;
439 HANDLE hmem;
440 int val;
441 int* p;
442 BOOL ret;
443
444 procid=GetCurrentProcessId();
445 hmem=pSHAllocShared(NULL,10,procid);
446 ok(hmem!=NULL,"SHAllocShared(NULL...) failed: %u\n", GetLastError());
447 ret = pSHFreeShared(hmem, procid);
448 ok( ret, "SHFreeShared failed: %u\n", GetLastError());
449
450 val=0x12345678;
451 hmem=pSHAllocShared(&val,4,procid);
452 ok(hmem!=NULL,"SHAllocShared(NULL...) failed: %u\n", GetLastError());
453
454 p=pSHLockShared(hmem,procid);
455 ok(p!=NULL,"SHLockShared failed: %u\n", GetLastError());
456 if (p!=NULL)
457 ok(*p==val,"Wrong value in shared memory: %d instead of %d\n",*p,val);
458 ret = pSHUnlockShared(p);
459 ok( ret, "SHUnlockShared failed: %u\n", GetLastError());
460
461 ret = pSHFreeShared(hmem, procid);
462 ok( ret, "SHFreeShared failed: %u\n", GetLastError());
463 }
464
465 static void test_fdsa(void)
466 {
467 typedef struct
468 {
469 DWORD num_items; /* Number of elements inserted */
470 void *mem; /* Ptr to array */
471 DWORD blocks_alloced; /* Number of elements allocated */
472 BYTE inc; /* Number of elements to grow by when we need to expand */
473 BYTE block_size; /* Size in bytes of an element */
474 BYTE flags; /* Flags */
475 } FDSA_info;
476
477 BOOL (WINAPI *pFDSA_Initialize)(DWORD block_size, DWORD inc, FDSA_info *info, void *mem,
478 DWORD init_blocks);
479 BOOL (WINAPI *pFDSA_Destroy)(FDSA_info *info);
480 DWORD (WINAPI *pFDSA_InsertItem)(FDSA_info *info, DWORD where, const void *block);
481 BOOL (WINAPI *pFDSA_DeleteItem)(FDSA_info *info, DWORD where);
482
483 FDSA_info info;
484 int block_size = 10, init_blocks = 4, inc = 2;
485 DWORD ret;
486 char *mem;
487
488 pFDSA_Initialize = (void *)GetProcAddress(hShlwapi, (LPSTR)208);
489 pFDSA_Destroy = (void *)GetProcAddress(hShlwapi, (LPSTR)209);
490 pFDSA_InsertItem = (void *)GetProcAddress(hShlwapi, (LPSTR)210);
491 pFDSA_DeleteItem = (void *)GetProcAddress(hShlwapi, (LPSTR)211);
492
493 mem = HeapAlloc(GetProcessHeap(), 0, block_size * init_blocks);
494 memset(&info, 0, sizeof(info));
495
496 ok(pFDSA_Initialize(block_size, inc, &info, mem, init_blocks), "FDSA_Initialize rets FALSE\n");
497 ok(info.num_items == 0, "num_items = %d\n", info.num_items);
498 ok(info.mem == mem, "mem = %p\n", info.mem);
499 ok(info.blocks_alloced == init_blocks, "blocks_alloced = %d\n", info.blocks_alloced);
500 ok(info.inc == inc, "inc = %d\n", info.inc);
501 ok(info.block_size == block_size, "block_size = %d\n", info.block_size);
502 ok(info.flags == 0, "flags = %d\n", info.flags);
503
504 ret = pFDSA_InsertItem(&info, 1234, "1234567890");
505 ok(ret == 0, "ret = %d\n", ret);
506 ok(info.num_items == 1, "num_items = %d\n", info.num_items);
507 ok(info.mem == mem, "mem = %p\n", info.mem);
508 ok(info.blocks_alloced == init_blocks, "blocks_alloced = %d\n", info.blocks_alloced);
509 ok(info.inc == inc, "inc = %d\n", info.inc);
510 ok(info.block_size == block_size, "block_size = %d\n", info.block_size);
511 ok(info.flags == 0, "flags = %d\n", info.flags);
512
513 ret = pFDSA_InsertItem(&info, 1234, "abcdefghij");
514 ok(ret == 1, "ret = %d\n", ret);
515
516 ret = pFDSA_InsertItem(&info, 1, "klmnopqrst");
517 ok(ret == 1, "ret = %d\n", ret);
518
519 ret = pFDSA_InsertItem(&info, 0, "uvwxyzABCD");
520 ok(ret == 0, "ret = %d\n", ret);
521 ok(info.mem == mem, "mem = %p\n", info.mem);
522 ok(info.flags == 0, "flags = %d\n", info.flags);
523
524 /* This next InsertItem will cause shlwapi to allocate its own mem buffer */
525 ret = pFDSA_InsertItem(&info, 0, "EFGHIJKLMN");
526 ok(ret == 0, "ret = %d\n", ret);
527 ok(info.mem != mem, "mem = %p\n", info.mem);
528 ok(info.blocks_alloced == init_blocks + inc, "blocks_alloced = %d\n", info.blocks_alloced);
529 ok(info.flags == 0x1, "flags = %d\n", info.flags);
530
531 ok(!memcmp(info.mem, "EFGHIJKLMNuvwxyzABCD1234567890klmnopqrstabcdefghij", 50), "mem %s\n", (char*)info.mem);
532
533 ok(pFDSA_DeleteItem(&info, 2), "rets FALSE\n");
534 ok(info.mem != mem, "mem = %p\n", info.mem);
535 ok(info.blocks_alloced == init_blocks + inc, "blocks_alloced = %d\n", info.blocks_alloced);
536 ok(info.flags == 0x1, "flags = %d\n", info.flags);
537
538 ok(!memcmp(info.mem, "EFGHIJKLMNuvwxyzABCDklmnopqrstabcdefghij", 40), "mem %s\n", (char*)info.mem);
539
540 ok(pFDSA_DeleteItem(&info, 3), "rets FALSE\n");
541 ok(info.mem != mem, "mem = %p\n", info.mem);
542 ok(info.blocks_alloced == init_blocks + inc, "blocks_alloced = %d\n", info.blocks_alloced);
543 ok(info.flags == 0x1, "flags = %d\n", info.flags);
544
545 ok(!memcmp(info.mem, "EFGHIJKLMNuvwxyzABCDklmnopqrst", 30), "mem %s\n", (char*)info.mem);
546
547 ok(!pFDSA_DeleteItem(&info, 4), "does not ret FALSE\n");
548
549 /* As shlwapi has allocated memory internally, Destroy will ret FALSE */
550 ok(!pFDSA_Destroy(&info), "FDSA_Destroy does not ret FALSE\n");
551
552
553 /* When Initialize is called with inc = 0, set it to 1 */
554 ok(pFDSA_Initialize(block_size, 0, &info, mem, init_blocks), "FDSA_Initialize rets FALSE\n");
555 ok(info.inc == 1, "inc = %d\n", info.inc);
556
557 /* This time, because shlwapi hasn't had to allocate memory
558 internally, Destroy rets non-zero */
559 ok(pFDSA_Destroy(&info), "FDSA_Destroy rets FALSE\n");
560
561
562 HeapFree(GetProcessHeap(), 0, mem);
563 }
564
565
566 typedef struct SHELL_USER_SID {
567 SID_IDENTIFIER_AUTHORITY sidAuthority;
568 DWORD dwUserGroupID;
569 DWORD dwUserID;
570 } SHELL_USER_SID, *PSHELL_USER_SID;
571 typedef struct SHELL_USER_PERMISSION {
572 SHELL_USER_SID susID;
573 DWORD dwAccessType;
574 BOOL fInherit;
575 DWORD dwAccessMask;
576 DWORD dwInheritMask;
577 DWORD dwInheritAccessMask;
578 } SHELL_USER_PERMISSION, *PSHELL_USER_PERMISSION;
579 static void test_GetShellSecurityDescriptor(void)
580 {
581 SHELL_USER_PERMISSION supCurrentUserFull = {
582 { {SECURITY_NULL_SID_AUTHORITY}, 0, 0 },
583 ACCESS_ALLOWED_ACE_TYPE, FALSE,
584 GENERIC_ALL, 0, 0 };
585 #define MY_INHERITANCE 0xBE /* invalid value to proof behavior */
586 SHELL_USER_PERMISSION supEveryoneDenied = {
587 { {SECURITY_WORLD_SID_AUTHORITY}, SECURITY_WORLD_RID, 0 },
588 ACCESS_DENIED_ACE_TYPE, TRUE,
589 GENERIC_WRITE, MY_INHERITANCE | 0xDEADBA00, GENERIC_READ };
590 PSHELL_USER_PERMISSION rgsup[2] = {
591 &supCurrentUserFull, &supEveryoneDenied,
592 };
593 SECURITY_DESCRIPTOR* psd;
594 SECURITY_DESCRIPTOR* (WINAPI*pGetShellSecurityDescriptor)(PSHELL_USER_PERMISSION*,int);
595 void *pChrCmpIW = GetProcAddress(hShlwapi, "ChrCmpIW");
596
597 pGetShellSecurityDescriptor=(void*)GetProcAddress(hShlwapi,(char*)475);
598
599 if(!pGetShellSecurityDescriptor)
600 {
601 win_skip("GetShellSecurityDescriptor not available\n");
602 return;
603 }
604
605 if(pChrCmpIW && pChrCmpIW == pGetShellSecurityDescriptor) /* win2k */
606 {
607 win_skip("Skipping for GetShellSecurityDescriptor, same ordinal used for ChrCmpIW\n");
608 return;
609 }
610
611 psd = pGetShellSecurityDescriptor(NULL, 2);
612 ok(psd==NULL ||
613 broken(psd==INVALID_HANDLE_VALUE), /* IE5 */
614 "GetShellSecurityDescriptor should fail\n");
615 psd = pGetShellSecurityDescriptor(rgsup, 0);
616 ok(psd==NULL, "GetShellSecurityDescriptor should fail, got %p\n", psd);
617
618 SetLastError(0xdeadbeef);
619 psd = pGetShellSecurityDescriptor(rgsup, 2);
620 if (psd == NULL && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
621 {
622 /* The previous calls to GetShellSecurityDescriptor don't set the last error */
623 win_skip("GetShellSecurityDescriptor is not implemented\n");
624 return;
625 }
626 if (psd == INVALID_HANDLE_VALUE)
627 {
628 win_skip("GetShellSecurityDescriptor is broken on IE5\n");
629 return;
630 }
631 ok(psd!=NULL, "GetShellSecurityDescriptor failed\n");
632 if (psd!=NULL)
633 {
634 BOOL bHasDacl = FALSE, bDefaulted;
635 PACL pAcl;
636 DWORD dwRev;
637 SECURITY_DESCRIPTOR_CONTROL control;
638
639 ok(IsValidSecurityDescriptor(psd), "returned value is not valid SD\n");
640
641 ok(GetSecurityDescriptorControl(psd, &control, &dwRev),
642 "GetSecurityDescriptorControl failed with error %u\n", GetLastError());
643 ok(0 == (control & SE_SELF_RELATIVE), "SD should be absolute\n");
644
645 ok(GetSecurityDescriptorDacl(psd, &bHasDacl, &pAcl, &bDefaulted),
646 "GetSecurityDescriptorDacl failed with error %u\n", GetLastError());
647
648 ok(bHasDacl, "SD has no DACL\n");
649 if (bHasDacl)
650 {
651 ok(!bDefaulted, "DACL should not be defaulted\n");
652
653 ok(pAcl != NULL, "NULL DACL!\n");
654 if (pAcl != NULL)
655 {
656 ACL_SIZE_INFORMATION asiSize;
657
658 ok(IsValidAcl(pAcl), "DACL is not valid\n");
659
660 ok(GetAclInformation(pAcl, &asiSize, sizeof(asiSize), AclSizeInformation),
661 "GetAclInformation failed with error %u\n", GetLastError());
662
663 ok(asiSize.AceCount == 3, "Incorrect number of ACEs: %d entries\n", asiSize.AceCount);
664 if (asiSize.AceCount == 3)
665 {
666 ACCESS_ALLOWED_ACE *paaa; /* will use for DENIED too */
667
668 ok(GetAce(pAcl, 0, (LPVOID*)&paaa), "GetAce failed with error %u\n", GetLastError());
669 ok(paaa->Header.AceType == ACCESS_ALLOWED_ACE_TYPE,
670 "Invalid ACE type %d\n", paaa->Header.AceType);
671 ok(paaa->Header.AceFlags == 0, "Invalid ACE flags %x\n", paaa->Header.AceFlags);
672 ok(paaa->Mask == GENERIC_ALL, "Invalid ACE mask %x\n", paaa->Mask);
673
674 ok(GetAce(pAcl, 1, (LPVOID*)&paaa), "GetAce failed with error %u\n", GetLastError());
675 ok(paaa->Header.AceType == ACCESS_DENIED_ACE_TYPE,
676 "Invalid ACE type %d\n", paaa->Header.AceType);
677 /* first one of two ACEs generated from inheritable entry - without inheritance */
678 ok(paaa->Header.AceFlags == 0, "Invalid ACE flags %x\n", paaa->Header.AceFlags);
679 ok(paaa->Mask == GENERIC_WRITE, "Invalid ACE mask %x\n", paaa->Mask);
680
681 ok(GetAce(pAcl, 2, (LPVOID*)&paaa), "GetAce failed with error %u\n", GetLastError());
682 ok(paaa->Header.AceType == ACCESS_DENIED_ACE_TYPE,
683 "Invalid ACE type %d\n", paaa->Header.AceType);
684 /* second ACE - with inheritance */
685 ok(paaa->Header.AceFlags == MY_INHERITANCE,
686 "Invalid ACE flags %x\n", paaa->Header.AceFlags);
687 ok(paaa->Mask == GENERIC_READ, "Invalid ACE mask %x\n", paaa->Mask);
688 }
689 }
690 }
691
692 LocalFree(psd);
693 }
694 }
695
696 static void test_SHPackDispParams(void)
697 {
698 DISPPARAMS params;
699 VARIANT vars[10];
700 HRESULT hres;
701
702 if(!pSHPackDispParams)
703 win_skip("SHPackSidpParams not available\n");
704
705 memset(&params, 0xc0, sizeof(params));
706 memset(vars, 0xc0, sizeof(vars));
707 hres = pSHPackDispParams(&params, vars, 1, VT_I4, 0xdeadbeef);
708 ok(hres == S_OK, "SHPackDispParams failed: %08x\n", hres);
709 ok(params.cArgs == 1, "params.cArgs = %d\n", params.cArgs);
710 ok(params.cNamedArgs == 0, "params.cNamedArgs = %d\n", params.cArgs);
711 ok(params.rgdispidNamedArgs == NULL, "params.rgdispidNamedArgs = %p\n", params.rgdispidNamedArgs);
712 ok(params.rgvarg == vars, "params.rgvarg = %p\n", params.rgvarg);
713 ok(V_VT(vars) == VT_I4, "V_VT(var) = %d\n", V_VT(vars));
714 ok(V_I4(vars) == 0xdeadbeef, "failed %x\n", V_I4(vars));
715
716 memset(&params, 0xc0, sizeof(params));
717 hres = pSHPackDispParams(&params, NULL, 0, 0);
718 ok(hres == S_OK, "SHPackDispParams failed: %08x\n", hres);
719 ok(params.cArgs == 0, "params.cArgs = %d\n", params.cArgs);
720 ok(params.cNamedArgs == 0, "params.cNamedArgs = %d\n", params.cArgs);
721 ok(params.rgdispidNamedArgs == NULL, "params.rgdispidNamedArgs = %p\n", params.rgdispidNamedArgs);
722 ok(params.rgvarg == NULL, "params.rgvarg = %p\n", params.rgvarg);
723
724 memset(vars, 0xc0, sizeof(vars));
725 memset(&params, 0xc0, sizeof(params));
726 hres = pSHPackDispParams(&params, vars, 4, VT_BSTR, (void*)0xdeadbeef, VT_EMPTY, 10,
727 VT_I4, 100, VT_DISPATCH, (void*)0xdeadbeef);
728 ok(hres == S_OK, "SHPackDispParams failed: %08x\n", hres);
729 ok(params.cArgs == 4, "params.cArgs = %d\n", params.cArgs);
730 ok(params.cNamedArgs == 0, "params.cNamedArgs = %d\n", params.cArgs);
731 ok(params.rgdispidNamedArgs == NULL, "params.rgdispidNamedArgs = %p\n", params.rgdispidNamedArgs);
732 ok(params.rgvarg == vars, "params.rgvarg = %p\n", params.rgvarg);
733 ok(V_VT(vars) == VT_DISPATCH, "V_VT(vars[0]) = %x\n", V_VT(vars));
734 ok(V_I4(vars) == 0xdeadbeef, "V_I4(vars[0]) = %x\n", V_I4(vars));
735 ok(V_VT(vars+1) == VT_I4, "V_VT(vars[1]) = %d\n", V_VT(vars+1));
736 ok(V_I4(vars+1) == 100, "V_I4(vars[1]) = %x\n", V_I4(vars+1));
737 ok(V_VT(vars+2) == VT_I4, "V_VT(vars[2]) = %d\n", V_VT(vars+2));
738 ok(V_I4(vars+2) == 10, "V_I4(vars[2]) = %x\n", V_I4(vars+2));
739 ok(V_VT(vars+3) == VT_BSTR, "V_VT(vars[3]) = %d\n", V_VT(vars+3));
740 ok(V_BSTR(vars+3) == (void*)0xdeadbeef, "V_BSTR(vars[3]) = %p\n", V_BSTR(vars+3));
741 }
742
743 typedef struct _disp
744 {
745 const IDispatchVtbl *vtbl;
746 LONG refCount;
747 } Disp;
748
749 typedef struct _contain
750 {
751 const IConnectionPointContainerVtbl *vtbl;
752 LONG refCount;
753
754 UINT ptCount;
755 IConnectionPoint **pt;
756 } Contain;
757
758 typedef struct _cntptn
759 {
760 const IConnectionPointVtbl *vtbl;
761 LONG refCount;
762
763 Contain *container;
764 GUID id;
765 UINT sinkCount;
766 IUnknown **sink;
767 } ConPt;
768
769 typedef struct _enum
770 {
771 const IEnumConnectionsVtbl *vtbl;
772 LONG refCount;
773
774 UINT idx;
775 ConPt *pt;
776 } EnumCon;
777
778 typedef struct _enumpt
779 {
780 const IEnumConnectionPointsVtbl *vtbl;
781 LONG refCount;
782
783 int idx;
784 Contain *container;
785 } EnumPt;
786
787
788 static HRESULT WINAPI Disp_QueryInterface(
789 IDispatch* This,
790 REFIID riid,
791 void **ppvObject)
792 {
793 *ppvObject = NULL;
794
795 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
796 {
797 *ppvObject = This;
798 }
799
800 if (*ppvObject)
801 {
802 IUnknown_AddRef(This);
803 return S_OK;
804 }
805
806 trace("no interface\n");
807 return E_NOINTERFACE;
808 }
809
810 static ULONG WINAPI Disp_AddRef(IDispatch* This)
811 {
812 Disp *iface = (Disp*)This;
813 return InterlockedIncrement(&iface->refCount);
814 }
815
816 static ULONG WINAPI Disp_Release(IDispatch* This)
817 {
818 Disp *iface = (Disp*)This;
819 ULONG ret;
820
821 ret = InterlockedDecrement(&iface->refCount);
822 if (ret == 0)
823 HeapFree(GetProcessHeap(),0,This);
824 return ret;
825 }
826
827 static HRESULT WINAPI Disp_GetTypeInfoCount(
828 IDispatch* This,
829 UINT *pctinfo)
830 {
831 return ERROR_SUCCESS;
832 }
833
834 static HRESULT WINAPI Disp_GetTypeInfo(
835 IDispatch* This,
836 UINT iTInfo,
837 LCID lcid,
838 ITypeInfo **ppTInfo)
839 {
840 return ERROR_SUCCESS;
841 }
842
843 static HRESULT WINAPI Disp_GetIDsOfNames(
844 IDispatch* This,
845 REFIID riid,
846 LPOLESTR *rgszNames,
847 UINT cNames,
848 LCID lcid,
849 DISPID *rgDispId)
850 {
851 return ERROR_SUCCESS;
852 }
853
854 static HRESULT WINAPI Disp_Invoke(
855 IDispatch* This,
856 DISPID dispIdMember,
857 REFIID riid,
858 LCID lcid,
859 WORD wFlags,
860 DISPPARAMS *pDispParams,
861 VARIANT *pVarResult,
862 EXCEPINFO *pExcepInfo,
863 UINT *puArgErr)
864 {
865 trace("%p %x %p %x %x %p %p %p %p\n",This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr);
866
867 ok(dispIdMember == 0xa0 || dispIdMember == 0xa1, "Unknown dispIdMember\n");
868 ok(pDispParams != NULL, "Invoked with NULL pDispParams\n");
869 ok(wFlags == DISPATCH_METHOD, "Wrong flags %x\n",wFlags);
870 ok(lcid == 0,"Wrong lcid %x\n",lcid);
871 if (dispIdMember == 0xa0)
872 {
873 ok(pDispParams->cArgs == 0, "params.cArgs = %d\n", pDispParams->cArgs);
874 ok(pDispParams->cNamedArgs == 0, "params.cNamedArgs = %d\n", pDispParams->cArgs);
875 ok(pDispParams->rgdispidNamedArgs == NULL, "params.rgdispidNamedArgs = %p\n", pDispParams->rgdispidNamedArgs);
876 ok(pDispParams->rgvarg == NULL, "params.rgvarg = %p\n", pDispParams->rgvarg);
877 }
878 else if (dispIdMember == 0xa1)
879 {
880 ok(pDispParams->cArgs == 2, "params.cArgs = %d\n", pDispParams->cArgs);
881 ok(pDispParams->cNamedArgs == 0, "params.cNamedArgs = %d\n", pDispParams->cArgs);
882 ok(pDispParams->rgdispidNamedArgs == NULL, "params.rgdispidNamedArgs = %p\n", pDispParams->rgdispidNamedArgs);
883 ok(V_VT(pDispParams->rgvarg) == VT_BSTR, "V_VT(var) = %d\n", V_VT(pDispParams->rgvarg));
884 ok(V_I4(pDispParams->rgvarg) == 0xdeadcafe , "failed %p\n", V_BSTR(pDispParams->rgvarg));
885 ok(V_VT(pDispParams->rgvarg+1) == VT_I4, "V_VT(var) = %d\n", V_VT(pDispParams->rgvarg+1));
886 ok(V_I4(pDispParams->rgvarg+1) == 0xdeadbeef, "failed %x\n", V_I4(pDispParams->rgvarg+1));
887 }
888
889 return ERROR_SUCCESS;
890 }
891
892 static const IDispatchVtbl disp_vtbl = {
893 Disp_QueryInterface,
894 Disp_AddRef,
895 Disp_Release,
896
897 Disp_GetTypeInfoCount,
898 Disp_GetTypeInfo,
899 Disp_GetIDsOfNames,
900 Disp_Invoke
901 };
902
903 static HRESULT WINAPI Enum_QueryInterface(
904 IEnumConnections* This,
905 REFIID riid,
906 void **ppvObject)
907 {
908 *ppvObject = NULL;
909
910 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IEnumConnections))
911 {
912 *ppvObject = This;
913 }
914
915 if (*ppvObject)
916 {
917 IUnknown_AddRef(This);
918 return S_OK;
919 }
920
921 trace("no interface\n");
922 return E_NOINTERFACE;
923 }
924
925 static ULONG WINAPI Enum_AddRef(IEnumConnections* This)
926 {
927 EnumCon *iface = (EnumCon*)This;
928 return InterlockedIncrement(&iface->refCount);
929 }
930
931 static ULONG WINAPI Enum_Release(IEnumConnections* This)
932 {
933 EnumCon *iface = (EnumCon*)This;
934 ULONG ret;
935
936 ret = InterlockedDecrement(&iface->refCount);
937 if (ret == 0)
938 HeapFree(GetProcessHeap(),0,This);
939 return ret;
940 }
941
942 static HRESULT WINAPI Enum_Next(
943 IEnumConnections* This,
944 ULONG cConnections,
945 LPCONNECTDATA rgcd,
946 ULONG *pcFetched)
947 {
948 EnumCon *iface = (EnumCon*)This;
949
950 if (cConnections > 0 && iface->idx < iface->pt->sinkCount)
951 {
952 rgcd->pUnk = iface->pt->sink[iface->idx];
953 IUnknown_AddRef(iface->pt->sink[iface->idx]);
954 rgcd->dwCookie=0xff;
955 if (pcFetched)
956 *pcFetched = 1;
957 iface->idx++;
958 return S_OK;
959 }
960
961 return E_FAIL;
962 }
963
964 static HRESULT WINAPI Enum_Skip(
965 IEnumConnections* This,
966 ULONG cConnections)
967 {
968 return E_FAIL;
969 }
970
971 static HRESULT WINAPI Enum_Reset(
972 IEnumConnections* This)
973 {
974 return E_FAIL;
975 }
976
977 static HRESULT WINAPI Enum_Clone(
978 IEnumConnections* This,
979 IEnumConnections **ppEnum)
980 {
981 return E_FAIL;
982 }
983
984 static const IEnumConnectionsVtbl enum_vtbl = {
985
986 Enum_QueryInterface,
987 Enum_AddRef,
988 Enum_Release,
989 Enum_Next,
990 Enum_Skip,
991 Enum_Reset,
992 Enum_Clone
993 };
994
995 static HRESULT WINAPI ConPt_QueryInterface(
996 IConnectionPoint* This,
997 REFIID riid,
998 void **ppvObject)
999 {
1000 *ppvObject = NULL;
1001
1002 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IConnectionPoint))
1003 {
1004 *ppvObject = This;
1005 }
1006
1007 if (*ppvObject)
1008 {
1009 IUnknown_AddRef(This);
1010 return S_OK;
1011 }
1012
1013 trace("no interface\n");
1014 return E_NOINTERFACE;
1015 }
1016
1017 static ULONG WINAPI ConPt_AddRef(
1018 IConnectionPoint* This)
1019 {
1020 ConPt *iface = (ConPt*)This;
1021 return InterlockedIncrement(&iface->refCount);
1022 }
1023
1024 static ULONG WINAPI ConPt_Release(
1025 IConnectionPoint* This)
1026 {
1027 ConPt *iface = (ConPt*)This;
1028 ULONG ret;
1029
1030 ret = InterlockedDecrement(&iface->refCount);
1031 if (ret == 0)
1032 {
1033 if (iface->sinkCount > 0)
1034 {
1035 int i;
1036 for (i = 0; i < iface->sinkCount; i++)
1037 {
1038 if (iface->sink[i])
1039 IUnknown_Release(iface->sink[i]);
1040 }
1041 HeapFree(GetProcessHeap(),0,iface->sink);
1042 }
1043 HeapFree(GetProcessHeap(),0,This);
1044 }
1045 return ret;
1046 }
1047
1048 static HRESULT WINAPI ConPt_GetConnectionInterface(
1049 IConnectionPoint* This,
1050 IID *pIID)
1051 {
1052 static int i = 0;
1053 ConPt *iface = (ConPt*)This;
1054 if (i==0)
1055 {
1056 i++;
1057 return E_FAIL;
1058 }
1059 else
1060 memcpy(pIID,&iface->id,sizeof(GUID));
1061 return S_OK;
1062 }
1063
1064 static HRESULT WINAPI ConPt_GetConnectionPointContainer(
1065 IConnectionPoint* This,
1066 IConnectionPointContainer **ppCPC)
1067 {
1068 ConPt *iface = (ConPt*)This;
1069
1070 *ppCPC = (IConnectionPointContainer*)iface->container;
1071 return S_OK;
1072 }
1073
1074 static HRESULT WINAPI ConPt_Advise(
1075 IConnectionPoint* This,
1076 IUnknown *pUnkSink,
1077 DWORD *pdwCookie)
1078 {
1079 ConPt *iface = (ConPt*)This;
1080
1081 if (iface->sinkCount == 0)
1082 iface->sink = HeapAlloc(GetProcessHeap(),0,sizeof(IUnknown*));
1083 else
1084 iface->sink = HeapReAlloc(GetProcessHeap(),0,iface->sink,sizeof(IUnknown*)*(iface->sinkCount+1));
1085 iface->sink[iface->sinkCount] = pUnkSink;
1086 IUnknown_AddRef(pUnkSink);
1087 iface->sinkCount++;
1088 *pdwCookie = iface->sinkCount;
1089 return S_OK;
1090 }
1091
1092 static HRESULT WINAPI ConPt_Unadvise(
1093 IConnectionPoint* This,
1094 DWORD dwCookie)
1095 {
1096 ConPt *iface = (ConPt*)This;
1097
1098 if (dwCookie > iface->sinkCount)
1099 return E_FAIL;
1100 else
1101 {
1102 IUnknown_Release(iface->sink[dwCookie-1]);
1103 iface->sink[dwCookie-1] = NULL;
1104 }
1105 return S_OK;
1106 }
1107
1108 static HRESULT WINAPI ConPt_EnumConnections(
1109 IConnectionPoint* This,
1110 IEnumConnections **ppEnum)
1111 {
1112 EnumCon *ec;
1113
1114 ec = HeapAlloc(GetProcessHeap(),0,sizeof(EnumCon));
1115 ec->vtbl = &enum_vtbl;
1116 ec->refCount = 1;
1117 ec->pt = (ConPt*)This;
1118 ec->idx = 0;
1119 *ppEnum = (IEnumConnections*)ec;
1120
1121 return S_OK;
1122 }
1123
1124 static const IConnectionPointVtbl point_vtbl = {
1125 ConPt_QueryInterface,
1126 ConPt_AddRef,
1127 ConPt_Release,
1128
1129 ConPt_GetConnectionInterface,
1130 ConPt_GetConnectionPointContainer,
1131 ConPt_Advise,
1132 ConPt_Unadvise,
1133 ConPt_EnumConnections
1134 };
1135
1136 static HRESULT WINAPI EnumPt_QueryInterface(
1137 IEnumConnectionPoints* This,
1138 REFIID riid,
1139 void **ppvObject)
1140 {
1141 *ppvObject = NULL;
1142
1143 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IEnumConnectionPoints))
1144 {
1145 *ppvObject = This;
1146 }
1147
1148 if (*ppvObject)
1149 {
1150 IUnknown_AddRef(This);
1151 return S_OK;
1152 }
1153
1154 trace("no interface\n");
1155 return E_NOINTERFACE;
1156 }
1157
1158 static ULONG WINAPI EnumPt_AddRef(IEnumConnectionPoints* This)
1159 {
1160 EnumPt *iface = (EnumPt*)This;
1161 return InterlockedIncrement(&iface->refCount);
1162 }
1163
1164 static ULONG WINAPI EnumPt_Release(IEnumConnectionPoints* This)
1165 {
1166 EnumPt *iface = (EnumPt*)This;
1167 ULONG ret;
1168
1169 ret = InterlockedDecrement(&iface->refCount);
1170 if (ret == 0)
1171 HeapFree(GetProcessHeap(),0,This);
1172 return ret;
1173 }
1174
1175 static HRESULT WINAPI EnumPt_Next(
1176 IEnumConnectionPoints* This,
1177 ULONG cConnections,
1178 IConnectionPoint **rgcd,
1179 ULONG *pcFetched)
1180 {
1181 EnumPt *iface = (EnumPt*)This;
1182
1183 if (cConnections > 0 && iface->idx < iface->container->ptCount)
1184 {
1185 *rgcd = iface->container->pt[iface->idx];
1186 IUnknown_AddRef(iface->container->pt[iface->idx]);
1187 if (pcFetched)
1188 *pcFetched = 1;
1189 iface->idx++;
1190 return S_OK;
1191 }
1192
1193 return E_FAIL;
1194 }
1195
1196 static HRESULT WINAPI EnumPt_Skip(
1197 IEnumConnectionPoints* This,
1198 ULONG cConnections)
1199 {
1200 return E_FAIL;
1201 }
1202
1203 static HRESULT WINAPI EnumPt_Reset(
1204 IEnumConnectionPoints* This)
1205 {
1206 return E_FAIL;
1207 }
1208
1209 static HRESULT WINAPI EnumPt_Clone(
1210 IEnumConnectionPoints* This,
1211 IEnumConnectionPoints **ppEnumPt)
1212 {
1213 return E_FAIL;
1214 }
1215
1216 static const IEnumConnectionPointsVtbl enumpt_vtbl = {
1217
1218 EnumPt_QueryInterface,
1219 EnumPt_AddRef,
1220 EnumPt_Release,
1221 EnumPt_Next,
1222 EnumPt_Skip,
1223 EnumPt_Reset,
1224 EnumPt_Clone
1225 };
1226
1227 static HRESULT WINAPI Contain_QueryInterface(
1228 IConnectionPointContainer* This,
1229 REFIID riid,
1230 void **ppvObject)
1231 {
1232 *ppvObject = NULL;
1233
1234 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IConnectionPointContainer))
1235 {
1236 *ppvObject = This;
1237 }
1238
1239 if (*ppvObject)
1240 {
1241 IUnknown_AddRef(This);
1242 return S_OK;
1243 }
1244
1245 trace("no interface\n");
1246 return E_NOINTERFACE;
1247 }
1248
1249 static ULONG WINAPI Contain_AddRef(
1250 IConnectionPointContainer* This)
1251 {
1252 Contain *iface = (Contain*)This;
1253 return InterlockedIncrement(&iface->refCount);
1254 }
1255
1256 static ULONG WINAPI Contain_Release(
1257 IConnectionPointContainer* This)
1258 {
1259 Contain *iface = (Contain*)This;
1260 ULONG ret;
1261
1262 ret = InterlockedDecrement(&iface->refCount);
1263 if (ret == 0)
1264 {
1265 if (iface->ptCount > 0)
1266 {
1267 int i;
1268 for (i = 0; i < iface->ptCount; i++)
1269 IUnknown_Release(iface->pt[i]);
1270 HeapFree(GetProcessHeap(),0,iface->pt);
1271 }
1272 HeapFree(GetProcessHeap(),0,This);
1273 }
1274 return ret;
1275 }
1276
1277 static HRESULT WINAPI Contain_EnumConnectionPoints(
1278 IConnectionPointContainer* This,
1279 IEnumConnectionPoints **ppEnum)
1280 {
1281 EnumPt *ec;
1282
1283 ec = HeapAlloc(GetProcessHeap(),0,sizeof(EnumPt));
1284 ec->vtbl = &enumpt_vtbl;
1285 ec->refCount = 1;
1286 ec->idx= 0;
1287 ec->container = (Contain*)This;
1288 *ppEnum = (IEnumConnectionPoints*)ec;
1289
1290 return S_OK;
1291 }
1292
1293 static HRESULT WINAPI Contain_FindConnectionPoint(
1294 IConnectionPointContainer* This,
1295 REFIID riid,
1296 IConnectionPoint **ppCP)
1297 {
1298 Contain *iface = (Contain*)This;
1299 ConPt *pt;
1300
1301 if (!IsEqualIID(riid, &IID_NULL) || iface->ptCount ==0)
1302 {
1303 pt = HeapAlloc(GetProcessHeap(),0,sizeof(ConPt));
1304 pt->vtbl = &point_vtbl;
1305 pt->refCount = 1;
1306 pt->sinkCount = 0;
1307 pt->sink = NULL;
1308 pt->container = iface;
1309 pt->id = IID_IDispatch;
1310
1311 if (iface->ptCount == 0)
1312 iface->pt =HeapAlloc(GetProcessHeap(),0,sizeof(IUnknown*));
1313 else
1314 iface->pt = HeapReAlloc(GetProcessHeap(),0,iface->pt,sizeof(IUnknown*)*(iface->ptCount+1));
1315 iface->pt[iface->ptCount] = (IConnectionPoint*)pt;
1316 iface->ptCount++;
1317
1318 *ppCP = (IConnectionPoint*)pt;
1319 }
1320 else
1321 {
1322 *ppCP = iface->pt[0];
1323 IUnknown_AddRef((IUnknown*)*ppCP);
1324 }
1325
1326 return S_OK;
1327 }
1328
1329 static const IConnectionPointContainerVtbl contain_vtbl = {
1330 Contain_QueryInterface,
1331 Contain_AddRef,
1332 Contain_Release,
1333
1334 Contain_EnumConnectionPoints,
1335 Contain_FindConnectionPoint
1336 };
1337
1338 static void test_IConnectionPoint(void)
1339 {
1340 HRESULT rc;
1341 ULONG ref;
1342 IConnectionPoint *point;
1343 Contain *container;
1344 Disp *dispatch;
1345 DWORD cookie = 0xffffffff;
1346 DISPPARAMS params;
1347 VARIANT vars[10];
1348
1349 if (!pIConnectionPoint_SimpleInvoke || !pConnectToConnectionPoint)
1350 {
1351 win_skip("IConnectionPoint Apis not present\n");
1352 return;
1353 }
1354
1355 container = HeapAlloc(GetProcessHeap(),0,sizeof(Contain));
1356 container->vtbl = &contain_vtbl;
1357 container->refCount = 1;
1358 container->ptCount = 0;
1359 container->pt = NULL;
1360
1361 dispatch = HeapAlloc(GetProcessHeap(),0,sizeof(Disp));
1362 dispatch->vtbl = &disp_vtbl;
1363 dispatch->refCount = 1;
1364
1365 rc = pConnectToConnectionPoint((IUnknown*)dispatch, &IID_NULL, TRUE, (IUnknown*)container, &cookie, &point);
1366 ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc);
1367 ok(point != NULL, "returned ConnectionPoint is NULL\n");
1368 ok(cookie != 0xffffffff, "invalid cookie returned\n");
1369
1370 rc = pIConnectionPoint_SimpleInvoke(point,0xa0,NULL);
1371 ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc);
1372
1373 if (pSHPackDispParams)
1374 {
1375 memset(&params, 0xc0, sizeof(params));
1376 memset(vars, 0xc0, sizeof(vars));
1377 rc = pSHPackDispParams(&params, vars, 2, VT_I4, 0xdeadbeef, VT_BSTR, 0xdeadcafe);
1378 ok(rc == S_OK, "SHPackDispParams failed: %08x\n", rc);
1379
1380 rc = pIConnectionPoint_SimpleInvoke(point,0xa1,&params);
1381 ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc);
1382 }
1383 else
1384 win_skip("pSHPackDispParams not present\n");
1385
1386 rc = pConnectToConnectionPoint(NULL, &IID_NULL, FALSE, (IUnknown*)container, &cookie, NULL);
1387 ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc);
1388
1389 /* MSDN says this should be required but it crashs on XP
1390 IUnknown_Release(point);
1391 */
1392 ref = IUnknown_Release((IUnknown*)container);
1393 ok(ref == 0, "leftover IConnectionPointContainer reference %i\n",ref);
1394 ref = IUnknown_Release((IUnknown*)dispatch);
1395 ok(ref == 0, "leftover IDispatch reference %i\n",ref);
1396 }
1397
1398 typedef struct _propbag
1399 {
1400 const IPropertyBagVtbl *vtbl;
1401 LONG refCount;
1402
1403 } PropBag;
1404
1405
1406 static HRESULT WINAPI Prop_QueryInterface(
1407 IPropertyBag* This,
1408 REFIID riid,
1409 void **ppvObject)
1410 {
1411 *ppvObject = NULL;
1412
1413 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IPropertyBag))
1414 {
1415 *ppvObject = This;
1416 }
1417
1418 if (*ppvObject)
1419 {
1420 IUnknown_AddRef(This);
1421 return S_OK;
1422 }
1423
1424 trace("no interface\n");
1425 return E_NOINTERFACE;
1426 }
1427
1428 static ULONG WINAPI Prop_AddRef(
1429 IPropertyBag* This)
1430 {
1431 PropBag *iface = (PropBag*)This;
1432 return InterlockedIncrement(&iface->refCount);
1433 }
1434
1435 static ULONG WINAPI Prop_Release(
1436 IPropertyBag* This)
1437 {
1438 PropBag *iface = (PropBag*)This;
1439 ULONG ret;
1440
1441 ret = InterlockedDecrement(&iface->refCount);
1442 if (ret == 0)
1443 HeapFree(GetProcessHeap(),0,This);
1444 return ret;
1445 }
1446
1447 static HRESULT WINAPI Prop_Read(
1448 IPropertyBag* This,
1449 LPCOLESTR pszPropName,
1450 VARIANT *pVar,
1451 IErrorLog *pErrorLog)
1452 {
1453 V_VT(pVar) = VT_BLOB|VT_BYREF;
1454 V_BYREF(pVar) = (LPVOID)0xdeadcafe;
1455 return S_OK;
1456 }
1457
1458 static HRESULT WINAPI Prop_Write(
1459 IPropertyBag* This,
1460 LPCOLESTR pszPropName,
1461 VARIANT *pVar)
1462 {
1463 return S_OK;
1464 }
1465
1466
1467 static const IPropertyBagVtbl prop_vtbl = {
1468 Prop_QueryInterface,
1469 Prop_AddRef,
1470 Prop_Release,
1471
1472 Prop_Read,
1473 Prop_Write
1474 };
1475
1476 static void test_SHPropertyBag_ReadLONG(void)
1477 {
1478 PropBag *pb;
1479 HRESULT rc;
1480 LONG out;
1481 static const WCHAR szName1[] = {'n','a','m','e','1',0};
1482
1483 if (!pSHPropertyBag_ReadLONG)
1484 {
1485 win_skip("SHPropertyBag_ReadLONG not present\n");
1486 return;
1487 }
1488
1489 pb = HeapAlloc(GetProcessHeap(),0,sizeof(PropBag));
1490 pb->refCount = 1;
1491 pb->vtbl = &prop_vtbl;
1492
1493 out = 0xfeedface;
1494 rc = pSHPropertyBag_ReadLONG(NULL, szName1, &out);
1495 ok(rc == E_INVALIDARG || broken(rc == 0), "incorrect return %x\n",rc);
1496 ok(out == 0xfeedface, "value should not have changed\n");
1497 rc = pSHPropertyBag_ReadLONG((IPropertyBag*)pb, NULL, &out);
1498 ok(rc == E_INVALIDARG || broken(rc == 0) || broken(rc == 1), "incorrect return %x\n",rc);
1499 ok(out == 0xfeedface, "value should not have changed\n");
1500 rc = pSHPropertyBag_ReadLONG((IPropertyBag*)pb, szName1, NULL);
1501 ok(rc == E_INVALIDARG || broken(rc == 0) || broken(rc == 1), "incorrect return %x\n",rc);
1502 ok(out == 0xfeedface, "value should not have changed\n");
1503 rc = pSHPropertyBag_ReadLONG((IPropertyBag*)pb, szName1, &out);
1504 ok(rc == DISP_E_BADVARTYPE || broken(rc == 0) || broken(rc == 1), "incorrect return %x\n",rc);
1505 ok(out == 0xfeedface || broken(out == 0xfeedfa00), "value should not have changed %x\n",out);
1506 IUnknown_Release((IUnknown*)pb);
1507 }
1508
1509
1510
1511 static void test_SHSetWindowBits(void)
1512 {
1513 HWND hwnd;
1514 DWORD style, styleold;
1515 WNDCLASSA clsA;
1516
1517 if(!pSHSetWindowBits)
1518 {
1519 win_skip("SHSetWindowBits is not available\n");
1520 return;
1521 }
1522
1523 clsA.style = 0;
1524 clsA.lpfnWndProc = DefWindowProcA;
1525 clsA.cbClsExtra = 0;
1526 clsA.cbWndExtra = 0;
1527 clsA.hInstance = GetModuleHandleA(NULL);
1528 clsA.hIcon = 0;
1529 clsA.hCursor = LoadCursorA(0, IDC_ARROW);
1530 clsA.hbrBackground = NULL;
1531 clsA.lpszMenuName = NULL;
1532 clsA.lpszClassName = "Shlwapi test class";
1533 RegisterClassA(&clsA);
1534
1535 hwnd = CreateWindowA("Shlwapi test class", "Test", WS_VISIBLE, 0, 0, 100, 100,
1536 NULL, NULL, GetModuleHandle(NULL), 0);
1537 ok(IsWindow(hwnd), "failed to create window\n");
1538
1539 /* null window */
1540 SetLastError(0xdeadbeef);
1541 style = pSHSetWindowBits(NULL, GWL_STYLE, 0, 0);
1542 ok(style == 0, "expected 0 retval, got %d\n", style);
1543 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE ||
1544 broken(GetLastError() == 0xdeadbeef), /* Win9x/WinMe */
1545 "expected ERROR_INVALID_WINDOW_HANDLE, got %d\n", GetLastError());
1546
1547 /* zero mask, zero flags */
1548 styleold = GetWindowLongA(hwnd, GWL_STYLE);
1549 style = pSHSetWindowBits(hwnd, GWL_STYLE, 0, 0);
1550 ok(styleold == style, "expected old style\n");
1551 ok(styleold == GetWindowLongA(hwnd, GWL_STYLE), "expected to keep old style\n");
1552
1553 /* test mask */
1554 styleold = GetWindowLongA(hwnd, GWL_STYLE);
1555 ok(styleold & WS_VISIBLE, "expected WS_VISIBLE\n");
1556 style = pSHSetWindowBits(hwnd, GWL_STYLE, WS_VISIBLE, 0);
1557
1558 ok(style == styleold, "expected previous style, got %x\n", style);
1559 ok((GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE) == 0, "expected updated style\n");
1560
1561 /* test mask, unset style bit used */
1562 styleold = GetWindowLongA(hwnd, GWL_STYLE);
1563 style = pSHSetWindowBits(hwnd, GWL_STYLE, WS_VISIBLE, 0);
1564 ok(style == styleold, "expected previous style, got %x\n", style);
1565 ok(styleold == GetWindowLongA(hwnd, GWL_STYLE), "expected to keep old style\n");
1566
1567 /* set back with flags */
1568 styleold = GetWindowLongA(hwnd, GWL_STYLE);
1569 style = pSHSetWindowBits(hwnd, GWL_STYLE, WS_VISIBLE, WS_VISIBLE);
1570 ok(style == styleold, "expected previous style, got %x\n", style);
1571 ok(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE, "expected updated style\n");
1572
1573 /* reset and try to set without a mask */
1574 pSHSetWindowBits(hwnd, GWL_STYLE, WS_VISIBLE, 0);
1575 ok((GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE) == 0, "expected updated style\n");
1576 styleold = GetWindowLongA(hwnd, GWL_STYLE);
1577 style = pSHSetWindowBits(hwnd, GWL_STYLE, 0, WS_VISIBLE);
1578 ok(style == styleold, "expected previous style, got %x\n", style);
1579 ok((GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE) == 0, "expected updated style\n");
1580
1581 DestroyWindow(hwnd);
1582
1583 UnregisterClassA("Shlwapi test class", GetModuleHandleA(NULL));
1584 }
1585
1586 static void test_SHFormatDateTimeA(void)
1587 {
1588 FILETIME UNALIGNED filetime;
1589 CHAR buff[100], buff2[100], buff3[100];
1590 SYSTEMTIME st;
1591 DWORD flags;
1592 INT ret;
1593
1594 if(!pSHFormatDateTimeA)
1595 {
1596 win_skip("pSHFormatDateTimeA isn't available\n");
1597 return;
1598 }
1599
1600 if (0)
1601 {
1602 /* crashes on native */
1603 ret = pSHFormatDateTimeA(NULL, NULL, NULL, 0);
1604 }
1605
1606 GetLocalTime(&st);
1607 SystemTimeToFileTime(&st, &filetime);
1608 /* SHFormatDateTime expects input as utc */
1609 LocalFileTimeToFileTime(&filetime, &filetime);
1610
1611 /* no way to get required buffer length here */
1612 SetLastError(0xdeadbeef);
1613 ret = pSHFormatDateTimeA(&filetime, NULL, NULL, 0);
1614 ok(ret == 0, "got %d\n", ret);
1615 ok(GetLastError() == 0xdeadbeef || broken(GetLastError() == ERROR_SUCCESS /* Win7 */),
1616 "expected 0xdeadbeef, got %d\n", GetLastError());
1617
1618 SetLastError(0xdeadbeef);
1619 buff[0] = 'a'; buff[1] = 0;
1620 ret = pSHFormatDateTimeA(&filetime, NULL, buff, 0);
1621 ok(ret == 0, "got %d\n", ret);
1622 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
1623 ok(buff[0] == 'a', "expected same string, got %s\n", buff);
1624
1625 /* flags needs to have FDTF_NOAUTOREADINGORDER for these tests to succeed on Vista+ */
1626
1627 /* all combinations documented as invalid succeeded */
1628 flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTTIME | FDTF_LONGTIME;
1629 SetLastError(0xdeadbeef);
1630 ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1631 ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1632 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
1633
1634 flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTDATE | FDTF_LONGDATE;
1635 SetLastError(0xdeadbeef);
1636 ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1637 ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1638 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
1639
1640 flags = FDTF_SHORTDATE | FDTF_LTRDATE | FDTF_RTLDATE;
1641 SetLastError(0xdeadbeef);
1642 ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1643 ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1644 ok(GetLastError() == 0xdeadbeef ||
1645 broken(GetLastError() == ERROR_INVALID_FLAGS), /* Win9x/WinMe */
1646 "expected 0xdeadbeef, got %d\n", GetLastError());
1647
1648 /* now check returned strings */
1649 flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTTIME;
1650 ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1651 ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1652 ret = GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff2, sizeof(buff2));
1653 ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1654 ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1655
1656 flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGTIME;
1657 ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1658 ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1659 ret = GetTimeFormat(LOCALE_USER_DEFAULT, 0, &st, NULL, buff2, sizeof(buff2));
1660 ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1661 ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1662
1663 /* both time flags */
1664 flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGTIME | FDTF_SHORTTIME;
1665 ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1666 ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1667 ret = GetTimeFormat(LOCALE_USER_DEFAULT, 0, &st, NULL, buff2, sizeof(buff2));
1668 ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1669 ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1670
1671 flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTDATE;
1672 ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1673 ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1674 ret = GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, sizeof(buff2));
1675 ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1676 ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1677
1678 flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGDATE;
1679 ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1680 ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1681 ret = GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2));
1682 ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1683 ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1684
1685 /* both date flags */
1686 flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGDATE | FDTF_SHORTDATE;
1687 ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1688 ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1689 ret = GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2));
1690 ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1691 ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1692
1693 /* various combinations of date/time flags */
1694 flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGDATE | FDTF_SHORTTIME;
1695 ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1696 ok(ret == lstrlenA(buff)+1, "got %d, length %d\n", ret, lstrlenA(buff)+1);
1697 ret = GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2));
1698 ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1699 strcat(buff2, ", ");
1700 ret = GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff3, sizeof(buff3));
1701 ok(ret == lstrlenA(buff3)+1, "got %d\n", ret);
1702 strcat(buff2, buff3);
1703 ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1704
1705 flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGDATE | FDTF_LONGTIME;
1706 ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1707 ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1708 ret = GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2));
1709 ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1710 strcat(buff2, ", ");
1711 ret = GetTimeFormat(LOCALE_USER_DEFAULT, 0, &st, NULL, buff3, sizeof(buff3));
1712 ok(ret == lstrlenA(buff3)+1, "got %d\n", ret);
1713 strcat(buff2, buff3);
1714 ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1715
1716 flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTDATE | FDTF_SHORTTIME;
1717 ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1718 ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1719 ret = GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, sizeof(buff2));
1720 ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1721 strcat(buff2, " ");
1722 ret = GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff3, sizeof(buff3));
1723 ok(ret == lstrlenA(buff3)+1, "got %d\n", ret);
1724 strcat(buff2, buff3);
1725 ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1726
1727 flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTDATE | FDTF_LONGTIME;
1728 ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1729 ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1730 ret = GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, sizeof(buff2));
1731 ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1732 strcat(buff2, " ");
1733 ret = GetTimeFormat(LOCALE_USER_DEFAULT, 0, &st, NULL, buff3, sizeof(buff3));
1734 ok(ret == lstrlenA(buff3)+1, "got %d\n", ret);
1735 strcat(buff2, buff3);
1736 ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1737 }
1738
1739 static void test_SHFormatDateTimeW(void)
1740 {
1741 FILETIME UNALIGNED filetime;
1742 WCHAR buff[100], buff2[100], buff3[100];
1743 SYSTEMTIME st;
1744 DWORD flags;
1745 INT ret;
1746 static const WCHAR spaceW[] = {' ',0};
1747 static const WCHAR commaW[] = {',',' ',0};
1748
1749 if(!pSHFormatDateTimeW)
1750 {
1751 win_skip("pSHFormatDateTimeW isn't available\n");
1752 return;
1753 }
1754
1755 if (0)
1756 {
1757 /* crashes on native */
1758 ret = pSHFormatDateTimeW(NULL, NULL, NULL, 0);
1759 }
1760
1761 GetLocalTime(&st);
1762 SystemTimeToFileTime(&st, &filetime);
1763 /* SHFormatDateTime expects input as utc */
1764 LocalFileTimeToFileTime(&filetime, &filetime);
1765
1766 /* no way to get required buffer length here */
1767 SetLastError(0xdeadbeef);
1768 ret = pSHFormatDateTimeW(&filetime, NULL, NULL, 0);
1769 ok(ret == 0, "got %d\n", ret);
1770 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
1771
1772 SetLastError(0xdeadbeef);
1773 buff[0] = 'a'; buff[1] = 0;
1774 ret = pSHFormatDateTimeW(&filetime, NULL, buff, 0);
1775 ok(ret == 0, "got %d\n", ret);
1776 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
1777 ok(buff[0] == 'a', "expected same string\n");
1778
1779 /* all combinations documented as invalid succeeded */
1780 flags = FDTF_SHORTTIME | FDTF_LONGTIME;
1781 SetLastError(0xdeadbeef);
1782 ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1783 ok(ret == lstrlenW(buff)+1, "got %d\n", ret);
1784 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
1785
1786 flags = FDTF_SHORTDATE | FDTF_LONGDATE;
1787 SetLastError(0xdeadbeef);
1788 ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1789 ok(ret == lstrlenW(buff)+1, "got %d\n", ret);
1790 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
1791
1792 flags = FDTF_SHORTDATE | FDTF_LTRDATE | FDTF_RTLDATE;
1793 SetLastError(0xdeadbeef);
1794 buff[0] = 0; /* NT4 doesn't clear the buffer on failure */
1795 ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1796 ok(ret == lstrlenW(buff)+1, "got %d\n", ret);
1797 ok(GetLastError() == 0xdeadbeef ||
1798 broken(GetLastError() == ERROR_INVALID_FLAGS), /* Win9x/WinMe/NT4 */
1799 "expected 0xdeadbeef, got %d\n", GetLastError());
1800
1801 /* now check returned strings */
1802 flags = FDTF_SHORTTIME;
1803 ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1804 ok(ret == lstrlenW(buff)+1, "got %d\n", ret);
1805 SetLastError(0xdeadbeef);
1806 ret = GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1807 if (ret == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1808 {
1809 win_skip("Needed W-functions are not implemented\n");
1810 return;
1811 }
1812 ok(ret == lstrlenW(buff2)+1, "got %d\n", ret);
1813 ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1814
1815 flags = FDTF_LONGTIME;
1816 ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1817 ok(ret == lstrlenW(buff)+1, "got %d\n", ret);
1818 ret = GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1819 ok(ret == lstrlenW(buff2)+1, "got %d\n", ret);
1820 ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1821
1822 /* both time flags */
1823 flags = FDTF_LONGTIME | FDTF_SHORTTIME;
1824 ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1825 ok(ret == lstrlenW(buff)+1, "got %d\n", ret);
1826 ret = GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1827 ok(ret == lstrlenW(buff2)+1, "got %d\n", ret);
1828 ok(lstrcmpW(buff, buff2) == 0, "expected equal string\n");
1829
1830 flags = FDTF_SHORTDATE;
1831 ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1832 ok(ret == lstrlenW(buff)+1, "got %d\n", ret);
1833 ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1834 ok(ret == lstrlenW(buff2)+1, "got %d\n", ret);
1835 ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1836
1837 flags = FDTF_LONGDATE;
1838 ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1839 ok(ret == lstrlenW(buff)+1, "got %d\n", ret);
1840 ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1841 ok(ret == lstrlenW(buff2)+1, "got %d\n", ret);
1842 ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1843
1844 /* both date flags */
1845 flags = FDTF_LONGDATE | FDTF_SHORTDATE;
1846 ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1847 ok(ret == lstrlenW(buff)+1, "got %d\n", ret);
1848 ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1849 ok(ret == lstrlenW(buff2)+1, "got %d\n", ret);
1850 ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1851
1852 /* various combinations of date/time flags */
1853 flags = FDTF_LONGDATE | FDTF_SHORTTIME;
1854 ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1855 ok(ret == lstrlenW(buff)+1, "got %d, length %d\n", ret, lstrlenW(buff)+1);
1856 ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1857 ok(ret == lstrlenW(buff2)+1, "got %d\n", ret);
1858 lstrcatW(buff2, commaW);
1859 ret = GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff3, sizeof(buff3)/sizeof(WCHAR));
1860 ok(ret == lstrlenW(buff3)+1, "got %d\n", ret);
1861 lstrcatW(buff2, buff3);
1862 ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1863
1864 flags = FDTF_LONGDATE | FDTF_LONGTIME;
1865 ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1866 ok(ret == lstrlenW(buff)+1, "got %d\n", ret);
1867 ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1868 ok(ret == lstrlenW(buff2)+1, "got %d\n", ret);
1869 lstrcatW(buff2, commaW);
1870 ret = GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, buff3, sizeof(buff3)/sizeof(WCHAR));
1871 ok(ret == lstrlenW(buff3)+1, "got %d\n", ret);
1872 lstrcatW(buff2, buff3);
1873 ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1874
1875 flags = FDTF_SHORTDATE | FDTF_SHORTTIME;
1876 ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1877 ok(ret == lstrlenW(buff)+1, "got %d\n", ret);
1878 ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1879 ok(ret == lstrlenW(buff2)+1, "got %d\n", ret);
1880 lstrcatW(buff2, spaceW);
1881 ret = GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff3, sizeof(buff3)/sizeof(WCHAR));
1882 ok(ret == lstrlenW(buff3)+1, "got %d\n", ret);
1883 lstrcatW(buff2, buff3);
1884 ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1885
1886 flags = FDTF_SHORTDATE | FDTF_LONGTIME;
1887 ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1888 ok(ret == lstrlenW(buff)+1, "got %d\n", ret);
1889 ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1890 ok(ret == lstrlenW(buff2)+1, "got %d\n", ret);
1891 lstrcatW(buff2, spaceW);
1892 ret = GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, buff3, sizeof(buff3)/sizeof(WCHAR));
1893 ok(ret == lstrlenW(buff3)+1, "got %d\n", ret);
1894 lstrcatW(buff2, buff3);
1895 ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1896 }
1897
1898 static void test_SHGetObjectCompatFlags(void)
1899 {
1900 struct compat_value {
1901 CHAR nameA[30];
1902 DWORD value;
1903 };
1904
1905 struct compat_value values[] = {
1906 { "OTNEEDSSFCACHE", 0x1 },
1907 { "NO_WEBVIEW", 0x2 },
1908 { "UNBINDABLE", 0x4 },
1909 { "PINDLL", 0x8 },
1910 { "NEEDSFILESYSANCESTOR", 0x10 },
1911 { "NOTAFILESYSTEM", 0x20 },
1912 { "CTXMENU_NOVERBS", 0x40 },
1913 { "CTXMENU_LIMITEDQI", 0x80 },
1914 { "COCREATESHELLFOLDERONLY", 0x100 },
1915 { "NEEDSSTORAGEANCESTOR", 0x200 },
1916 { "NOLEGACYWEBVIEW", 0x400 },
1917 { "CTXMENU_XPQCMFLAGS", 0x1000 },
1918 { "NOIPROPERTYSTORE", 0x2000 }
1919 };
1920
1921 static const char compat_path[] = "Software\\Microsoft\\Windows\\CurrentVersion\\ShellCompatibility\\Objects";
1922 void *pColorAdjustLuma = GetProcAddress(hShlwapi, "ColorAdjustLuma");
1923 CHAR keyA[39]; /* {CLSID} */
1924 HKEY root;
1925 DWORD ret;
1926 int i;
1927
1928 if (!pSHGetObjectCompatFlags)
1929 {
1930 win_skip("SHGetObjectCompatFlags isn't available\n");
1931 return;
1932 }
1933
1934 if (pColorAdjustLuma && pColorAdjustLuma == pSHGetObjectCompatFlags) /* win2k */
1935 {
1936 win_skip("Skipping SHGetObjectCompatFlags, same ordinal used for ColorAdjustLuma\n");
1937 return;
1938 }
1939
1940 /* null args */
1941 ret = pSHGetObjectCompatFlags(NULL, NULL);
1942 ok(ret == 0, "got %d\n", ret);
1943
1944 ret = RegOpenKeyA(HKEY_LOCAL_MACHINE, compat_path, &root);
1945 if (ret != ERROR_SUCCESS)
1946 {
1947 skip("No compatibility class data found\n");
1948 return;
1949 }
1950
1951 for (i = 0; RegEnumKeyA(root, i, keyA, sizeof(keyA)) == ERROR_SUCCESS; i++)
1952 {
1953 HKEY clsid_key;
1954
1955 if (RegOpenKeyA(root, keyA, &clsid_key) == ERROR_SUCCESS)
1956 {
1957 CHAR valueA[30];
1958 DWORD expected = 0, got, length = sizeof(valueA);
1959 CLSID clsid;
1960 int v;
1961
1962 for (v = 0; RegEnumValueA(clsid_key, v, valueA, &length, NULL, NULL, NULL, NULL) == ERROR_SUCCESS; v++)
1963 {
1964 int j;
1965
1966 for (j = 0; j < sizeof(values)/sizeof(struct compat_value); j++)
1967 if (lstrcmpA(values[j].nameA, valueA) == 0)
1968 {
1969 expected |= values[j].value;
1970 break;
1971 }
1972
1973 length = sizeof(valueA);
1974 }
1975
1976 pGUIDFromStringA(keyA, &clsid);
1977 got = pSHGetObjectCompatFlags(NULL, &clsid);
1978 ok(got == expected, "got 0x%08x, expected 0x%08x. Key %s\n", got, expected, keyA);
1979
1980 RegCloseKey(clsid_key);
1981 }
1982 }
1983
1984 RegCloseKey(root);
1985 }
1986
1987 typedef struct {
1988 const IOleCommandTargetVtbl *lpVtbl;
1989 LONG ref;
1990 } IOleCommandTargetImpl;
1991
1992 static const IOleCommandTargetVtbl IOleCommandTargetImpl_Vtbl;
1993
1994 static IOleCommandTarget* IOleCommandTargetImpl_Construct(void)
1995 {
1996 IOleCommandTargetImpl *obj;
1997
1998 obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
1999 obj->lpVtbl = &IOleCommandTargetImpl_Vtbl;
2000 obj->ref = 1;
2001
2002 return (IOleCommandTarget*)obj;
2003 }
2004
2005 static HRESULT WINAPI IOleCommandTargetImpl_QueryInterface(IOleCommandTarget *iface, REFIID riid, void **ppvObj)
2006 {
2007 IOleCommandTargetImpl *This = (IOleCommandTargetImpl *)iface;
2008
2009 if (IsEqualIID(riid, &IID_IUnknown) ||
2010 IsEqualIID(riid, &IID_IOleCommandTarget))
2011 {
2012 *ppvObj = This;
2013 }
2014
2015 if(*ppvObj)
2016 {
2017 IUnknown_AddRef(iface);
2018 return S_OK;
2019 }
2020
2021 return E_NOINTERFACE;
2022 }
2023
2024 static ULONG WINAPI IOleCommandTargetImpl_AddRef(IOleCommandTarget *iface)
2025 {
2026 IOleCommandTargetImpl *This = (IOleCommandTargetImpl *)iface;
2027 return InterlockedIncrement(&This->ref);
2028 }
2029
2030 static ULONG WINAPI IOleCommandTargetImpl_Release(IOleCommandTarget *iface)
2031 {
2032 IOleCommandTargetImpl *This = (IOleCommandTargetImpl *)iface;
2033 ULONG ref = InterlockedDecrement(&This->ref);
2034
2035 if (!ref)
2036 {
2037 HeapFree(GetProcessHeap(), 0, This);
2038 return 0;
2039 }
2040 return ref;
2041 }
2042
2043 static HRESULT WINAPI IOleCommandTargetImpl_QueryStatus(
2044 IOleCommandTarget *iface, const GUID *group, ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
2045 {
2046 return E_NOTIMPL;
2047 }
2048
2049 static HRESULT WINAPI IOleCommandTargetImpl_Exec(
2050 IOleCommandTarget *iface,
2051 const GUID *CmdGroup,
2052 DWORD nCmdID,
2053 DWORD nCmdexecopt,
2054 VARIANT *pvaIn,
2055 VARIANT *pvaOut)
2056 {
2057 add_call(&trace_got, 3, CmdGroup, (void*)(DWORD_PTR)nCmdID, (void*)(DWORD_PTR)nCmdexecopt, pvaIn, pvaOut);
2058 return S_OK;
2059 }
2060
2061 static const IOleCommandTargetVtbl IOleCommandTargetImpl_Vtbl =
2062 {
2063 IOleCommandTargetImpl_QueryInterface,
2064 IOleCommandTargetImpl_AddRef,
2065 IOleCommandTargetImpl_Release,
2066 IOleCommandTargetImpl_QueryStatus,
2067 IOleCommandTargetImpl_Exec
2068 };
2069
2070 typedef struct {
2071 const IServiceProviderVtbl *lpVtbl;
2072 LONG ref;
2073 } IServiceProviderImpl;
2074
2075 typedef struct {
2076 const IProfferServiceVtbl *lpVtbl;
2077 LONG ref;
2078 } IProfferServiceImpl;
2079
2080
2081 static const IServiceProviderVtbl IServiceProviderImpl_Vtbl;
2082 static const IProfferServiceVtbl IProfferServiceImpl_Vtbl;
2083
2084 static IServiceProvider* IServiceProviderImpl_Construct(void)
2085 {
2086 IServiceProviderImpl *obj;
2087
2088 obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
2089 obj->lpVtbl = &IServiceProviderImpl_Vtbl;
2090 obj->ref = 1;
2091
2092 return (IServiceProvider*)obj;
2093 }
2094
2095 static IProfferService* IProfferServiceImpl_Construct(void)
2096 {
2097 IProfferServiceImpl *obj;
2098
2099 obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
2100 obj->lpVtbl = &IProfferServiceImpl_Vtbl;
2101 obj->ref = 1;
2102
2103 return (IProfferService*)obj;
2104 }
2105
2106 static HRESULT WINAPI IServiceProviderImpl_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppvObj)
2107 {
2108 IServiceProviderImpl *This = (IServiceProviderImpl *)iface;
2109
2110 if (IsEqualIID(riid, &IID_IUnknown) ||
2111 IsEqualIID(riid, &IID_IServiceProvider))
2112 {
2113 *ppvObj = This;
2114 }
2115
2116 if(*ppvObj)
2117 {
2118 IUnknown_AddRef(iface);
2119 /* native uses redefined IID_IServiceProvider symbol, so we can't compare pointers */
2120 if (IsEqualIID(riid, &IID_IServiceProvider))
2121 add_call(&trace_got, 1, iface, &IID_IServiceProvider, 0, 0, 0);
2122 return S_OK;
2123 }
2124
2125 return E_NOINTERFACE;
2126 }
2127
2128 static ULONG WINAPI IServiceProviderImpl_AddRef(IServiceProvider *iface)
2129 {
2130 IServiceProviderImpl *This = (IServiceProviderImpl *)iface;
2131 return InterlockedIncrement(&This->ref);
2132 }
2133
2134 static ULONG WINAPI IServiceProviderImpl_Release(IServiceProvider *iface)
2135 {
2136 IServiceProviderImpl *This = (IServiceProviderImpl *)iface;
2137 ULONG ref = InterlockedDecrement(&This->ref);
2138
2139 if (!ref)
2140 {
2141 HeapFree(GetProcessHeap(), 0, This);
2142 return 0;
2143 }
2144 return ref;
2145 }
2146
2147 static HRESULT WINAPI IServiceProviderImpl_QueryService(
2148 IServiceProvider *iface, REFGUID service, REFIID riid, void **ppv)
2149 {
2150 /* native uses redefined pointer for IID_IOleCommandTarget, not one from uuid.lib */
2151 if (IsEqualIID(riid, &IID_IOleCommandTarget))
2152 {
2153 add_call(&trace_got, 2, iface, service, &IID_IOleCommandTarget, 0, 0);
2154 *ppv = IOleCommandTargetImpl_Construct();
2155 }
2156 if (IsEqualIID(riid, &IID_IProfferService))
2157 {
2158 if (IsEqualIID(service, &IID_IProfferService))
2159 add_call(&trace_got, 2, &IID_IProfferService, &IID_IProfferService, 0, 0, 0);
2160 *ppv = IProfferServiceImpl_Construct();
2161 }
2162 return S_OK;
2163 }
2164
2165 static const IServiceProviderVtbl IServiceProviderImpl_Vtbl =
2166 {
2167 IServiceProviderImpl_QueryInterface,
2168 IServiceProviderImpl_AddRef,
2169 IServiceProviderImpl_Release,
2170 IServiceProviderImpl_QueryService
2171 };
2172
2173 static void test_IUnknown_QueryServiceExec(void)
2174 {
2175 IServiceProvider *provider = IServiceProviderImpl_Construct();
2176 static const GUID dummy_serviceid = { 0xdeadbeef };
2177 static const GUID dummy_groupid = { 0xbeefbeef };
2178 call_trace_t trace_expected;
2179 HRESULT hr;
2180
2181 /* on <=W2K platforms same ordinal used for another export with different
2182 prototype, so skipping using this indirect condition */
2183 if (is_win2k_and_lower)
2184 {
2185 win_skip("IUnknown_QueryServiceExec is not available\n");
2186 return;
2187 }
2188
2189 /* null source pointer */
2190 hr = pIUnknown_QueryServiceExec(NULL, &dummy_serviceid, &dummy_groupid, 0, 0, 0, 0);
2191 ok(hr == E_FAIL, "got 0x%08x\n", hr);
2192
2193 /* expected trace:
2194 IUnknown_QueryServiceExec( ptr1, serviceid, groupid, arg1, arg2, arg3, arg4);
2195 -> IUnknown_QueryInterface( ptr1, &IID_IServiceProvider, &prov );
2196 -> IServiceProvider_QueryService( prov, serviceid, &IID_IOleCommandTarget, &obj );
2197 -> IOleCommandTarget_Exec( obj, groupid, arg1, arg2, arg3, arg4 );
2198 */
2199 init_call_trace(&trace_expected);
2200
2201 add_call(&trace_expected, 1, provider, &IID_IServiceProvider, 0, 0, 0);
2202 add_call(&trace_expected, 2, provider, &dummy_serviceid, &IID_IOleCommandTarget, 0, 0);
2203 add_call(&trace_expected, 3, &dummy_groupid, (void*)0x1, (void*)0x2, (void*)0x3, (void*)0x4);
2204
2205 init_call_trace(&trace_got);
2206 hr = pIUnknown_QueryServiceExec((IUnknown*)provider, &dummy_serviceid, &dummy_groupid, 0x1, 0x2, (void*)0x3, (void*)0x4);
2207 ok(hr == S_OK, "got 0x%08x\n", hr);
2208
2209 ok_trace(&trace_expected, &trace_got);
2210
2211 free_call_trace(&trace_expected);
2212 free_call_trace(&trace_got);
2213
2214 IServiceProvider_Release(provider);
2215 }
2216
2217
2218 static HRESULT WINAPI IProfferServiceImpl_QueryInterface(IProfferService *iface, REFIID riid, void **ppvObj)
2219 {
2220 IProfferServiceImpl *This = (IProfferServiceImpl *)iface;
2221
2222 if (IsEqualIID(riid, &IID_IUnknown) ||
2223 IsEqualIID(riid, &IID_IProfferService))
2224 {
2225 *ppvObj = This;
2226 }
2227 else if (IsEqualIID(riid, &IID_IServiceProvider))
2228 {
2229 *ppvObj = IServiceProviderImpl_Construct();
2230 add_call(&trace_got, 1, iface, &IID_IServiceProvider, 0, 0, 0);
2231 return S_OK;
2232 }
2233
2234 if(*ppvObj)
2235 {
2236 IUnknown_AddRef(iface);
2237 return S_OK;
2238 }
2239
2240 return E_NOINTERFACE;
2241 }
2242
2243 static ULONG WINAPI IProfferServiceImpl_AddRef(IProfferService *iface)
2244 {
2245 IProfferServiceImpl *This = (IProfferServiceImpl *)iface;
2246 return InterlockedIncrement(&This->ref);
2247 }
2248
2249 static ULONG WINAPI IProfferServiceImpl_Release(IProfferService *iface)
2250 {
2251 IProfferServiceImpl *This = (IProfferServiceImpl *)iface;
2252 ULONG ref = InterlockedDecrement(&This->ref);
2253
2254 if (!ref)
2255 {
2256 HeapFree(GetProcessHeap(), 0, This);
2257 return 0;
2258 }
2259 return ref;
2260 }
2261
2262 static HRESULT WINAPI IProfferServiceImpl_ProfferService(IProfferService *iface,
2263 REFGUID service, IServiceProvider *pService, DWORD *pCookie)
2264 {
2265 add_call(&trace_got, 3, service, pService, pCookie, 0, 0);
2266 return S_OK;
2267 }
2268
2269 static HRESULT WINAPI IProfferServiceImpl_RevokeService(IProfferService *iface, DWORD cookie)
2270 {
2271 add_call(&trace_got, 4, (void*)(DWORD_PTR)cookie, 0, 0, 0, 0);
2272 return S_OK;
2273 }
2274
2275 static const IProfferServiceVtbl IProfferServiceImpl_Vtbl =
2276 {
2277 IProfferServiceImpl_QueryInterface,
2278 IProfferServiceImpl_AddRef,
2279 IProfferServiceImpl_Release,
2280 IProfferServiceImpl_ProfferService,
2281 IProfferServiceImpl_RevokeService
2282 };
2283
2284 static void test_IUnknown_ProfferService(void)
2285 {
2286 IServiceProvider *provider = IServiceProviderImpl_Construct();
2287 IProfferService *proff = IProfferServiceImpl_Construct();
2288 static const GUID dummy_serviceid = { 0xdeadbeef };
2289 call_trace_t trace_expected;
2290 HRESULT hr;
2291 DWORD cookie;
2292
2293 /* on <=W2K platforms same ordinal used for another export with different
2294 prototype, so skipping using this indirect condition */
2295 if (is_win2k_and_lower)
2296 {
2297 win_skip("IUnknown_ProfferService is not available\n");
2298 return;
2299 }
2300
2301 /* null source pointer */
2302 hr = pIUnknown_ProfferService(NULL, &dummy_serviceid, 0, 0);
2303 ok(hr == E_FAIL, "got 0x%08x\n", hr);
2304
2305 /* expected trace:
2306 IUnknown_ProfferService( ptr1, serviceid, arg1, arg2);
2307 -> IUnknown_QueryInterface( ptr1, &IID_IServiceProvider, &provider );
2308 -> IServiceProvider_QueryService( provider, &IID_IProfferService, &IID_IProfferService, &proffer );
2309
2310 if (service pointer not null):
2311 -> IProfferService_ProfferService( proffer, serviceid, arg1, arg2 );
2312 else
2313 -> IProfferService_RevokeService( proffer, *arg2 );
2314 */
2315 init_call_trace(&trace_expected);
2316
2317 add_call(&trace_expected, 1, proff, &IID_IServiceProvider, 0, 0, 0);
2318 add_call(&trace_expected, 2, &IID_IProfferService, &IID_IProfferService, 0, 0, 0);
2319 add_call(&trace_expected, 3, &dummy_serviceid, provider, &cookie, 0, 0);
2320
2321 init_call_trace(&trace_got);
2322 hr = pIUnknown_ProfferService((IUnknown*)proff, &dummy_serviceid, provider, &cookie);
2323 ok(hr == S_OK, "got 0x%08x\n", hr);
2324
2325 ok_trace(&trace_expected, &trace_got);
2326 free_call_trace(&trace_got);
2327 free_call_trace(&trace_expected);
2328
2329 /* same with ::Revoke path */
2330 init_call_trace(&trace_expected);
2331
2332 add_call(&trace_expected, 1, proff, &IID_IServiceProvider, 0, 0, 0);
2333 add_call(&trace_expected, 2, &IID_IProfferService, &IID_IProfferService, 0, 0, 0);
2334 add_call(&trace_expected, 4, (void*)(DWORD_PTR)cookie, 0, 0, 0, 0);
2335
2336 init_call_trace(&trace_got);
2337 hr = pIUnknown_ProfferService((IUnknown*)proff, &dummy_serviceid, 0, &cookie);
2338 ok(hr == S_OK, "got 0x%08x\n", hr);
2339 ok_trace(&trace_expected, &trace_got);
2340 free_call_trace(&trace_got);
2341 free_call_trace(&trace_expected);
2342
2343 IServiceProvider_Release(provider);
2344 IProfferService_Release(proff);
2345 }
2346
2347 static void test_SHCreateWorkerWindowA(void)
2348 {
2349 WNDCLASSA cliA;
2350 char classA[20];
2351 HWND hwnd;
2352 LONG_PTR ret;
2353 BOOL res;
2354
2355 if (is_win2k_and_lower)
2356 {
2357 win_skip("SHCreateWorkerWindowA not available\n");
2358 return;
2359 }
2360
2361 hwnd = pSHCreateWorkerWindowA(0, NULL, 0, 0, 0, 0);
2362 ok(hwnd != 0, "expected window\n");
2363
2364 GetClassName(hwnd, classA, 20);
2365 ok(lstrcmpA(classA, "WorkerA") == 0, "expected WorkerA class, got %s\n", classA);
2366
2367 ret = GetWindowLongPtrA(hwnd, 0);
2368 ok(ret == 0, "got %ld\n", ret);
2369
2370 /* class info */
2371 memset(&cliA, 0, sizeof(cliA));
2372 res = GetClassInfoA(GetModuleHandle("shlwapi.dll"), "WorkerA", &cliA);
2373 ok(res, "failed to get class info\n");
2374 ok(cliA.style == 0, "got 0x%08x\n", cliA.style);
2375 ok(cliA.cbClsExtra == 0, "got %d\n", cliA.cbClsExtra);
2376 ok(cliA.cbWndExtra == sizeof(LONG_PTR), "got %d\n", cliA.cbWndExtra);
2377 ok(cliA.lpszMenuName == 0, "got %s\n", cliA.lpszMenuName);
2378
2379 DestroyWindow(hwnd);
2380
2381 /* set extra bytes */
2382 hwnd = pSHCreateWorkerWindowA(0, NULL, 0, 0, 0, 0xdeadbeef);
2383 ok(hwnd != 0, "expected window\n");
2384
2385 GetClassName(hwnd, classA, 20);
2386 ok(lstrcmpA(classA, "WorkerA") == 0, "expected WorkerA class, got %s\n", classA);
2387
2388 ret = GetWindowLongPtrA(hwnd, 0);
2389 ok(ret == 0xdeadbeef, "got %ld\n", ret);
2390
2391 /* test exstyle */
2392 ret = GetWindowLongA(hwnd, GWL_EXSTYLE);
2393 ok(ret == WS_EX_WINDOWEDGE ||
2394 ret == (WS_EX_WINDOWEDGE|WS_EX_LAYOUTRTL) /* systems with RTL locale */, "0x%08lx\n", ret);
2395
2396 DestroyWindow(hwnd);
2397
2398 hwnd = pSHCreateWorkerWindowA(0, NULL, WS_EX_TOOLWINDOW, 0, 0, 0);
2399 ret = GetWindowLongA(hwnd, GWL_EXSTYLE);
2400 ok(ret == (WS_EX_WINDOWEDGE|WS_EX_TOOLWINDOW) ||
2401 ret == (WS_EX_WINDOWEDGE|WS_EX_TOOLWINDOW|WS_EX_LAYOUTRTL) /* systems with RTL locale */, "0x%08lx\n", ret);
2402 DestroyWindow(hwnd);
2403 }
2404
2405 static HRESULT WINAPI SF_QueryInterface(IShellFolder *iface,
2406 REFIID riid, void **ppv)
2407 {
2408 /* SHIShellFolder_EnumObjects doesn't QI the object for IShellFolder */
2409 ok(!IsEqualGUID(&IID_IShellFolder, riid),
2410 "Unexpected QI for IShellFolder\n");
2411 return E_NOINTERFACE;
2412 }
2413
2414 static ULONG WINAPI SF_AddRef(IShellFolder *iface)
2415 {
2416 return 2;
2417 }
2418
2419 static ULONG WINAPI SF_Release(IShellFolder *iface)
2420 {
2421 return 1;
2422 }
2423
2424 static HRESULT WINAPI SF_ParseDisplayName(IShellFolder *iface,
2425 HWND owner, LPBC reserved, LPOLESTR displayName, ULONG *eaten,
2426 LPITEMIDLIST *idl, ULONG *attr)
2427 {
2428 ok(0, "Didn't expect ParseDisplayName\n");
2429 return E_NOTIMPL;
2430 }
2431
2432 static HRESULT WINAPI SF_EnumObjects(IShellFolder *iface,
2433 HWND owner, SHCONTF flags, IEnumIDList **enm)
2434 {
2435 *enm = (IEnumIDList*)0xcafebabe;
2436 return S_OK;
2437 }
2438
2439 static HRESULT WINAPI SF_BindToObject(IShellFolder *iface,
2440 LPCITEMIDLIST idl, LPBC reserved, REFIID riid, void **obj)
2441 {
2442 ok(0, "Didn't expect BindToObject\n");
2443 return E_NOTIMPL;
2444 }
2445
2446 static HRESULT WINAPI SF_BindToStorage(IShellFolder *iface,
2447 LPCITEMIDLIST idl, LPBC reserved, REFIID riid, void **obj)
2448 {
2449 ok(0, "Didn't expect BindToStorage\n");
2450 return E_NOTIMPL;
2451 }
2452
2453 static HRESULT WINAPI SF_CompareIDs(IShellFolder *iface,
2454 LPARAM lparam, LPCITEMIDLIST idl1, LPCITEMIDLIST idl2)
2455 {
2456 ok(0, "Didn't expect CompareIDs\n");
2457 return E_NOTIMPL;
2458 }
2459
2460 static HRESULT WINAPI SF_CreateViewObject(IShellFolder *iface,
2461 HWND owner, REFIID riid, void **out)
2462 {
2463 ok(0, "Didn't expect CreateViewObject\n");
2464 return E_NOTIMPL;
2465 }
2466
2467 static HRESULT WINAPI SF_GetAttributesOf(IShellFolder *iface,
2468 UINT cidl, LPCITEMIDLIST *idl, SFGAOF *inOut)
2469 {
2470 ok(0, "Didn't expect GetAttributesOf\n");
2471 return E_NOTIMPL;
2472 }
2473
2474 static HRESULT WINAPI SF_GetUIObjectOf(IShellFolder *iface,
2475 HWND owner, UINT cidl, LPCITEMIDLIST *idls, REFIID riid, UINT *inOut,
2476 void **out)
2477 {
2478 ok(0, "Didn't expect GetUIObjectOf\n");
2479 return E_NOTIMPL;
2480 }
2481
2482 static HRESULT WINAPI SF_GetDisplayNameOf(IShellFolder *iface,
2483 LPCITEMIDLIST idl, SHGDNF flags, STRRET *name)
2484 {
2485 ok(0, "Didn't expect GetDisplayNameOf\n");
2486 return E_NOTIMPL;
2487 }
2488
2489 static HRESULT WINAPI SF_SetNameOf(IShellFolder *iface,
2490 HWND hwnd, LPCITEMIDLIST idl, LPCOLESTR name, SHGDNF flags,
2491 LPITEMIDLIST *idlOut)
2492 {
2493 ok(0, "Didn't expect SetNameOf\n");
2494 return E_NOTIMPL;
2495 }
2496
2497 static IShellFolderVtbl ShellFolderVtbl = {
2498 SF_QueryInterface,
2499 SF_AddRef,
2500 SF_Release,
2501 SF_ParseDisplayName,
2502 SF_EnumObjects,
2503 SF_BindToObject,
2504 SF_BindToStorage,
2505 SF_CompareIDs,
2506 SF_CreateViewObject,
2507 SF_GetAttributesOf,
2508 SF_GetUIObjectOf,
2509 SF_GetDisplayNameOf,
2510 SF_SetNameOf
2511 };
2512
2513 static IShellFolder ShellFolder = { &ShellFolderVtbl };
2514
2515 static void test_SHIShellFolder_EnumObjects(void)
2516 {
2517 IEnumIDList *enm;
2518 HRESULT hres;
2519 IShellFolder *folder;
2520
2521 if(!pSHIShellFolder_EnumObjects || is_win2k_and_lower){
2522 win_skip("SHIShellFolder_EnumObjects not available\n");
2523 return;
2524 }
2525
2526 if(0){
2527 /* NULL object crashes on Windows */
2528 hres = pSHIShellFolder_EnumObjects(NULL, NULL, 0, NULL);
2529 }
2530
2531 /* SHIShellFolder_EnumObjects doesn't QI the object for IShellFolder */
2532 enm = (IEnumIDList*)0xdeadbeef;
2533 hres = pSHIShellFolder_EnumObjects(&ShellFolder, NULL, 0, &enm);
2534 ok(hres == S_OK, "SHIShellFolder_EnumObjects failed: 0x%08x\n", hres);
2535 ok(enm == (IEnumIDList*)0xcafebabe, "Didn't get expected enumerator location, instead: %p\n", enm);
2536
2537 /* SHIShellFolder_EnumObjects isn't strict about the IShellFolder object */
2538 hres = pSHGetDesktopFolder(&folder);
2539 ok(hres == S_OK, "SHGetDesktopFolder failed: 0x%08x\n", hres);
2540
2541 enm = NULL;
2542 hres = pSHIShellFolder_EnumObjects(folder, NULL, 0, &enm);
2543 ok(hres == S_OK, "SHIShellFolder_EnumObjects failed: 0x%08x\n", hres);
2544 ok(enm != NULL, "Didn't get an enumerator\n");
2545 if(enm)
2546 IEnumIDList_Release(enm);
2547
2548 IShellFolder_Release(folder);
2549 }
2550
2551 static void write_inifile(LPCWSTR filename)
2552 {
2553 DWORD written;
2554 HANDLE file;
2555
2556 static const char data[] =
2557 "[TestApp]\r\n"
2558 "AKey=1\r\n"
2559 "AnotherKey=asdf\r\n";
2560
2561 file = CreateFileW(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
2562 if(file == INVALID_HANDLE_VALUE)
2563 return;
2564
2565 WriteFile(file, data, sizeof(data), &written, NULL);
2566
2567 CloseHandle(file);
2568 }
2569
2570 #define verify_inifile(f, e) r_verify_inifile(__LINE__, f, e)
2571 static void r_verify_inifile(unsigned l, LPCWSTR filename, LPCSTR exp)
2572 {
2573 HANDLE file;
2574 CHAR buf[1024];
2575 DWORD read;
2576
2577 file = CreateFileW(filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
2578 if(file == INVALID_HANDLE_VALUE)
2579 return;
2580
2581 ReadFile(file, buf, sizeof(buf) * sizeof(CHAR), &read, NULL);
2582 buf[read] = '\0';
2583
2584 CloseHandle(file);
2585
2586 ok_(__FILE__,l)(!strcmp(buf, exp), "Expected:\n%s\nGot:\n%s\n", exp,
2587 buf);
2588 }
2589
2590 static void test_SHGetIniString(void)
2591 {
2592 DWORD ret;
2593 WCHAR out[64] = {0};
2594
2595 static const WCHAR TestAppW[] = {'T','e','s','t','A','p','p',0};
2596 static const WCHAR TestIniW[] = {'C',':','\\','t','e','s','t','.','i','n','i',0};
2597 static const WCHAR AKeyW[] = {'A','K','e','y',0};
2598 static const WCHAR AnotherKeyW[] = {'A','n','o','t','h','e','r','K','e','y',0};
2599 static const WCHAR JunkKeyW[] = {'J','u','n','k','K','e','y',0};
2600
2601 if(!pSHGetIniStringW || is_win2k_and_lower){
2602 win_skip("SHGetIniStringW is not available\n");
2603 return;
2604 }
2605
2606 write_inifile(TestIniW);
2607
2608 if(0){
2609 /* these crash on Windows */
2610 ret = pSHGetIniStringW(NULL, NULL, NULL, 0, NULL);
2611 ret = pSHGetIniStringW(NULL, AKeyW, out, sizeof(out), TestIniW);
2612 ret = pSHGetIniStringW(TestAppW, AKeyW, NULL, sizeof(out), TestIniW);
2613 }
2614
2615 ret = pSHGetIniStringW(TestAppW, AKeyW, out, 0, TestIniW);
2616 ok(ret == 0, "SHGetIniStringW should have given 0, instead: %d\n", ret);
2617
2618 /* valid arguments */
2619 ret = pSHGetIniStringW(TestAppW, NULL, out, sizeof(out), TestIniW);
2620 ok(broken(ret == 0) || /* win 98 */
2621 ret == 4, "SHGetIniStringW should have given 4, instead: %d\n", ret);
2622 ok(!lstrcmpW(out, AKeyW), "Expected %s, got: %s\n",
2623 wine_dbgstr_w(AKeyW), wine_dbgstr_w(out));
2624
2625 ret = pSHGetIniStringW(TestAppW, AKeyW, out, sizeof(out), TestIniW);
2626 ok(broken(ret == 0) || /* win 98 */
2627 ret == 1, "SHGetIniStringW should have given 1, instead: %d\n", ret);
2628 ok(broken(*out == 0) || /*win 98 */
2629 !strcmp_wa(out, "1"), "Expected L\"1\", got: %s\n", wine_dbgstr_w(out));
2630
2631 ret = pSHGetIniStringW(TestAppW, AnotherKeyW, out, sizeof(out), TestIniW);
2632 ok(broken(ret == 0) || /* win 98 */
2633 ret == 4, "SHGetIniStringW should have given 4, instead: %d\n", ret);
2634 ok(broken(*out == 0) || /* win 98 */
2635 !strcmp_wa(out, "asdf"), "Expected L\"asdf\", got: %s\n", wine_dbgstr_w(out));
2636
2637 ret = pSHGetIniStringW(TestAppW, JunkKeyW, out, sizeof(out), TestIniW);
2638 ok(ret == 0, "SHGetIniStringW should have given 0, instead: %d\n", ret);
2639 ok(*out == 0, "Expected L\"\", got: %s\n", wine_dbgstr_w(out));
2640
2641 DeleteFileW(TestIniW);
2642 }
2643
2644 static void test_SHSetIniString(void)
2645 {
2646 BOOL ret;
2647
2648 static const WCHAR TestAppW[] = {'T','e','s','t','A','p','p',0};
2649 static const WCHAR AnotherAppW[] = {'A','n','o','t','h','e','r','A','p','p',0};
2650 static const WCHAR TestIniW[] = {'C',':','\\','t','e','s','t','.','i','n','i',0};
2651 static const WCHAR AKeyW[] = {'A','K','e','y',0};
2652 static const WCHAR NewKeyW[] = {'N','e','w','K','e','y',0};
2653 static const WCHAR AValueW[] = {'A','V','a','l','u','e',0};
2654
2655 if(!pSHSetIniStringW || is_win2k_and_lower){
2656 win_skip("SHSetIniStringW is not available\n");
2657 return;
2658 }
2659
2660 write_inifile(TestIniW);
2661
2662 ret = pSHSetIniStringW(TestAppW, AKeyW, AValueW, TestIniW);
2663 ok(ret == TRUE, "SHSetIniStringW should not have failed\n");
2664 todo_wine /* wine sticks an extra \r\n at the end of the file */
2665 verify_inifile(TestIniW, "[TestApp]\r\nAKey=AValue\r\nAnotherKey=asdf\r\n");
2666
2667 ret = pSHSetIniStringW(TestAppW, AKeyW, NULL, TestIniW);
2668 ok(ret == TRUE, "SHSetIniStringW should not have failed\n");
2669 verify_inifile(TestIniW, "[TestApp]\r\nAnotherKey=asdf\r\n");
2670
2671 ret = pSHSetIniStringW(AnotherAppW, NewKeyW, AValueW, TestIniW);
2672 ok(ret == TRUE, "SHSetIniStringW should not have failed\n");
2673 verify_inifile(TestIniW, "[TestApp]\r\nAnotherKey=asdf\r\n[AnotherApp]\r\nNewKey=AValue\r\n");
2674
2675 ret = pSHSetIniStringW(TestAppW, NULL, AValueW, TestIniW);
2676 ok(ret == TRUE, "SHSetIniStringW should not have failed\n");
2677 verify_inifile(TestIniW, "[AnotherApp]\r\nNewKey=AValue\r\n");
2678
2679 DeleteFileW(TestIniW);
2680 }
2681
2682 enum _shellkey_flags {
2683 SHKEY_Explorer = 0x00,
2684 SHKEY_Root_HKCU = 0x01
2685 };
2686
2687 static void test_SHGetShellKey(void)
2688 {
2689 void *pPathBuildRootW = GetProcAddress(hShlwapi, "PathBuildRootW");
2690 HKEY hkey, hkey2;
2691 DWORD ret;
2692
2693 if (!pSHGetShellKey)
2694 {
2695 win_skip("SHGetShellKey(ordinal 491) isn't available\n");
2696 return;
2697 }
2698
2699 /* some win2k */
2700 if (pPathBuildRootW && pPathBuildRootW == pSHGetShellKey)
2701 {
2702 win_skip("SHGetShellKey(ordinal 491) used for PathBuildRootW\n");
2703 return;
2704 }
2705
2706 if (is_win9x || is_win2k_and_lower)
2707 {
2708 win_skip("Ordinal 491 used for another call, skipping SHGetShellKey tests\n");
2709 return;
2710 }
2711
2712 /* marking broken cause latest Vista+ versions fail here */
2713 SetLastError(0xdeadbeef);
2714 hkey = pSHGetShellKey(SHKEY_Explorer, NULL, FALSE);
2715 ok(hkey == NULL || broken(hkey != NULL), "got %p\n", hkey);
2716 if (hkey)
2717 {
2718 hkey2 = 0;
2719 ret = RegOpenKeyExA(hkey, "Shell Folders", 0, KEY_READ, &hkey2);
2720 ok(ret == ERROR_SUCCESS, "got %d\n", ret);
2721 ok(hkey2 != NULL, "got %p\n", hkey2);
2722 RegCloseKey( hkey2 );
2723 RegCloseKey( hkey );
2724 }
2725
2726 hkey = pSHGetShellKey(SHKEY_Explorer | SHKEY_Root_HKCU, NULL, FALSE);
2727 ok(hkey != NULL, "got %p\n", hkey);
2728
2729 hkey2 = 0;
2730 ret = RegOpenKeyExA(hkey, "Shell Folders", 0, KEY_READ, &hkey2);
2731 ok(ret == ERROR_SUCCESS, "got %d\n", ret);
2732 ok(hkey2 != NULL, "got %p\n", hkey2);
2733 RegCloseKey( hkey2 );
2734
2735 RegCloseKey( hkey );
2736 }
2737
2738 static void init_pointers(void)
2739 {
2740 #define MAKEFUNC(f, ord) (p##f = (void*)GetProcAddress(hShlwapi, (LPSTR)(ord)))
2741 MAKEFUNC(SHAllocShared, 7);
2742 MAKEFUNC(SHLockShared, 8);
2743 MAKEFUNC(SHUnlockShared, 9);
2744 MAKEFUNC(SHFreeShared, 10);
2745 MAKEFUNC(GetAcceptLanguagesA, 14);
2746 MAKEFUNC(SHSetWindowBits, 165);
2747 MAKEFUNC(ConnectToConnectionPoint, 168);
2748 MAKEFUNC(SHSearchMapInt, 198);
2749 MAKEFUNC(SHCreateWorkerWindowA, 257);
2750 MAKEFUNC(GUIDFromStringA, 269);
2751 MAKEFUNC(SHPackDispParams, 282);
2752 MAKEFUNC(IConnectionPoint_InvokeWithCancel, 283);
2753 MAKEFUNC(IConnectionPoint_SimpleInvoke, 284);
2754 MAKEFUNC(SHGetIniStringW, 294);
2755 MAKEFUNC(SHSetIniStringW, 295);
2756 MAKEFUNC(SHFormatDateTimeA, 353);
2757 MAKEFUNC(SHFormatDateTimeW, 354);
2758 MAKEFUNC(SHIShellFolder_EnumObjects, 404);
2759 MAKEFUNC(SHGetObjectCompatFlags, 476);
2760 MAKEFUNC(IUnknown_QueryServiceExec, 484);
2761 MAKEFUNC(SHGetShellKey, 491);
2762 MAKEFUNC(SHPropertyBag_ReadLONG, 496);
2763 MAKEFUNC(IUnknown_ProfferService, 514);
2764 #undef MAKEFUNC
2765 }
2766
2767 START_TEST(ordinal)
2768 {
2769 hShlwapi = GetModuleHandleA("shlwapi.dll");
2770 is_win2k_and_lower = GetProcAddress(hShlwapi, "StrChrNW") == 0;
2771 is_win9x = GetProcAddress(hShlwapi, (LPSTR)99) == 0; /* StrCpyNXA */
2772
2773 init_pointers();
2774
2775 hmlang = LoadLibraryA("mlang.dll");
2776 pLcidToRfc1766A = (void *)GetProcAddress(hmlang, "LcidToRfc1766A");
2777
2778 hshell32 = LoadLibraryA("shell32.dll");
2779 pSHGetDesktopFolder = (void *)GetProcAddress(hshell32, "SHGetDesktopFolder");
2780
2781 test_GetAcceptLanguagesA();
2782 test_SHSearchMapInt();
2783 test_alloc_shared();
2784 test_fdsa();
2785 test_GetShellSecurityDescriptor();
2786 test_SHPackDispParams();
2787 test_IConnectionPoint();
2788 test_SHPropertyBag_ReadLONG();
2789 test_SHSetWindowBits();
2790 test_SHFormatDateTimeA();
2791 test_SHFormatDateTimeW();
2792 test_SHGetObjectCompatFlags();
2793 test_IUnknown_QueryServiceExec();
2794 test_IUnknown_ProfferService();
2795 test_SHCreateWorkerWindowA();
2796 test_SHIShellFolder_EnumObjects();
2797 test_SHGetIniString();
2798 test_SHSetIniString();
2799 test_SHGetShellKey();
2800
2801 FreeLibrary(hshell32);
2802 FreeLibrary(hmlang);
2803 }
Wine tree for Wine Gecko development