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