[BROWSEUI_WINETEST] Sync with Wine Staging 3.3. CORE-14434
[reactos.git] / modules / rostests / winetests / browseui / autocomplete.c
1 /* Unit tests for autocomplete
2 *
3 * Copyright 2007 Mikolaj Zalewski
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 #define COBJMACROS
21
22 #include <stdarg.h>
23
24 #include <initguid.h>
25 #include <windows.h>
26 #include <shlobj.h>
27 #include <shldisp.h>
28 #include <shlwapi.h>
29 #include <shlguid.h>
30
31 #include "wine/test.h"
32
33 #define ole_ok(exp) \
34 { \
35 HRESULT res = (exp); \
36 if (res != S_OK) \
37 ok(FALSE, #exp " failed: %x\n", res); \
38 }
39
40 static LPWSTR strdup_AtoW(LPCSTR str)
41 {
42 int size = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
43 LPWSTR wstr = CoTaskMemAlloc((size + 1)*sizeof(WCHAR));
44 MultiByteToWideChar(CP_ACP, 0, str, -1, wstr, size+1);
45 return wstr;
46 }
47
48 typedef struct
49 {
50 IEnumString IEnumString_iface;
51 IACList IACList_iface;
52 LONG ref;
53 HRESULT expret;
54 INT expcount;
55 INT pos;
56 INT limit;
57 const char **data;
58 } TestACL;
59
60 extern IEnumStringVtbl TestACLVtbl;
61 extern IACListVtbl TestACL_ACListVtbl;
62
63 static inline TestACL *impl_from_IEnumString(IEnumString *iface)
64 {
65 return CONTAINING_RECORD(iface, TestACL, IEnumString_iface);
66 }
67
68 static TestACL *impl_from_IACList(IACList *iface)
69 {
70 return CONTAINING_RECORD(iface, TestACL, IACList_iface);
71 }
72
73 static TestACL *TestACL_Constructor(int limit, const char **strings)
74 {
75 TestACL *This = CoTaskMemAlloc(sizeof(TestACL));
76 ZeroMemory(This, sizeof(*This));
77 This->IEnumString_iface.lpVtbl = &TestACLVtbl;
78 This->IACList_iface.lpVtbl = &TestACL_ACListVtbl;
79 This->ref = 1;
80 This->expret = S_OK;
81 This->limit = limit;
82 This->data = strings;
83 return This;
84 }
85
86 static ULONG STDMETHODCALLTYPE TestACL_AddRef(IEnumString *iface)
87 {
88 TestACL *This = impl_from_IEnumString(iface);
89 trace("ACL(%p): addref (%d)\n", This, This->ref+1);
90 return InterlockedIncrement(&This->ref);
91 }
92
93 static ULONG STDMETHODCALLTYPE TestACL_Release(IEnumString *iface)
94 {
95 TestACL *This = impl_from_IEnumString(iface);
96 ULONG res;
97
98 res = InterlockedDecrement(&This->ref);
99 trace("ACL(%p): release (%d)\n", This, res);
100 return res;
101 }
102
103 static HRESULT STDMETHODCALLTYPE TestACL_QueryInterface(IEnumString *iface, REFIID iid, LPVOID *ppvOut)
104 {
105 TestACL *This = impl_from_IEnumString(iface);
106 *ppvOut = NULL;
107 if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IEnumString))
108 {
109 *ppvOut = iface;
110 }
111 else if (IsEqualGUID(iid, &IID_IACList))
112 {
113 *ppvOut = &This->IACList_iface;
114 }
115
116 if (*ppvOut)
117 {
118 IEnumString_AddRef(iface);
119 return S_OK;
120 }
121
122 if (!IsEqualGUID(iid, &IID_IEnumACString))
123 trace("unknown interface queried\n");
124 return E_NOINTERFACE;
125 }
126
127 static HRESULT STDMETHODCALLTYPE TestACL_Next(IEnumString *iface, ULONG celt, LPOLESTR *rgelt, ULONG *pceltFetched)
128 {
129 TestACL *This = impl_from_IEnumString(iface);
130 ULONG i;
131
132 trace("ACL(%p): read %d item(s)\n", This, celt);
133 for (i = 0; i < celt; i++)
134 {
135 if (This->pos >= This->limit)
136 break;
137 rgelt[i] = strdup_AtoW(This->data[This->pos]);
138 This->pos++;
139 }
140
141 if (pceltFetched)
142 *pceltFetched = i;
143 if (i == celt)
144 return S_OK;
145 return S_FALSE;
146 }
147
148 static HRESULT STDMETHODCALLTYPE TestACL_Skip(IEnumString *iface, ULONG celt)
149 {
150 ok(FALSE, "Unexpected call to TestACL_Skip\n");
151 return E_NOTIMPL;
152 }
153
154 static HRESULT STDMETHODCALLTYPE TestACL_Clone(IEnumString *iface, IEnumString **out)
155 {
156 ok(FALSE, "Unexpected call to TestACL_Clone\n");
157 return E_OUTOFMEMORY;
158 }
159
160 static HRESULT STDMETHODCALLTYPE TestACL_Reset(IEnumString *iface)
161 {
162 TestACL *This = impl_from_IEnumString(iface);
163 trace("ACL(%p): Reset\n", This);
164 This->pos = 0;
165 return S_OK;
166 }
167
168 static HRESULT STDMETHODCALLTYPE TestACL_Expand(IACList *iface, LPCOLESTR str)
169 {
170 TestACL *This = impl_from_IACList(iface);
171 trace("ACL(%p): Expand\n", This);
172 This->expcount++;
173 return This->expret;
174 }
175
176 IEnumStringVtbl TestACLVtbl =
177 {
178 TestACL_QueryInterface,
179 TestACL_AddRef,
180 TestACL_Release,
181
182 TestACL_Next,
183 TestACL_Skip,
184 TestACL_Reset,
185 TestACL_Clone
186 };
187
188 static ULONG STDMETHODCALLTYPE TestACL_ACList_AddRef(IACList *iface)
189 {
190 TestACL *This = impl_from_IACList(iface);
191 return TestACL_AddRef(&This->IEnumString_iface);
192 }
193
194 static ULONG STDMETHODCALLTYPE TestACL_ACList_Release(IACList *iface)
195 {
196 TestACL *This = impl_from_IACList(iface);
197 return TestACL_Release(&This->IEnumString_iface);
198 }
199
200 static HRESULT STDMETHODCALLTYPE TestACL_ACList_QueryInterface(IACList *iface, REFIID iid, LPVOID *ppvout)
201 {
202 TestACL *This = impl_from_IACList(iface);
203 return TestACL_QueryInterface(&This->IEnumString_iface, iid, ppvout);
204 }
205
206 IACListVtbl TestACL_ACListVtbl =
207 {
208 TestACL_ACList_QueryInterface,
209 TestACL_ACList_AddRef,
210 TestACL_ACList_Release,
211
212 TestACL_Expand
213 };
214
215 #define expect_str(obj, str) \
216 { \
217 ole_ok(IEnumString_Next(obj, 1, &wstr, &i)); \
218 ok(i == 1, "Expected i == 1, got %d\n", i); \
219 ok(str[0] == wstr[0], "String mismatch\n"); \
220 CoTaskMemFree(wstr); \
221 }
222
223 #define expect_end(obj) \
224 ok(IEnumString_Next(obj, 1, &wstr, &i) == S_FALSE, "Unexpected return from Next\n");
225
226 static void test_ACLMulti(void)
227 {
228 const char *strings1[] = {"a", "c", "e"};
229 const char *strings2[] = {"a", "b", "d"};
230 WCHAR exp[] = {'A','B','C',0};
231 IEnumString *obj;
232 IEnumACString *unk;
233 HRESULT hr;
234 TestACL *acl1, *acl2;
235 IACList *acl;
236 IObjMgr *mgr;
237 LPWSTR wstr;
238 LPWSTR wstrtab[15];
239 LPVOID tmp;
240 ULONG ref;
241 UINT i;
242
243 hr = CoCreateInstance(&CLSID_ACLMulti, NULL, CLSCTX_INPROC, &IID_IEnumString, (void**)&obj);
244 ok(hr == S_OK, "failed to create ACLMulti instance, 0x%08x\n", hr);
245 if (hr != S_OK) return;
246
247 hr = IEnumString_QueryInterface(obj, &IID_IACList, (void**)&acl);
248 ok(hr == S_OK, "got 0x%08x\n", hr);
249 hr = IEnumString_QueryInterface(obj, &IID_IACList2, &tmp);
250 ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);
251 hr = IEnumString_QueryInterface(obj, &IID_IObjMgr, (void**)&mgr);
252 ok(hr == S_OK, "got 0x%08x\n", hr);
253
254 hr = IEnumString_QueryInterface(obj, &IID_IEnumACString, (LPVOID*)&unk);
255 if (hr == E_NOINTERFACE)
256 todo_wine win_skip("IEnumACString is not supported, skipping tests\n");
257 else
258 {
259 ok(hr == S_OK, "QueryInterface(IID_IEnumACString) failed: %x\n", hr);
260 if (unk != NULL)
261 IEnumACString_Release(unk);
262 }
263
264 i = -1;
265 hr = IEnumString_Next(obj, 1, (LPOLESTR *)&tmp, &i);
266 ok(hr == S_FALSE, "got 0x%08x\n", hr);
267 ok(i == 0, "Unexpected fetched value %d\n", i);
268 hr = IEnumString_Next(obj, 44, (LPOLESTR *)&tmp, &i);
269 ok(hr == S_FALSE, "got 0x%08x\n", hr);
270 hr = IEnumString_Skip(obj, 1);
271 ok(hr == E_NOTIMPL, "got 0x%08x\n", hr);
272 hr = IEnumString_Clone(obj, (IEnumString **)&tmp);
273 ok(hr == E_OUTOFMEMORY, "got 0x%08x\n", hr);
274 hr = IACList_Expand(acl, exp);
275 ok(hr == S_OK, "got 0x%08x\n", hr);
276
277 acl1 = TestACL_Constructor(3, strings1);
278 acl2 = TestACL_Constructor(3, strings2);
279 hr = IObjMgr_Append(mgr, (IUnknown *)&acl1->IACList_iface);
280 ok(hr == S_OK, "got 0x%08x\n", hr);
281 hr = IObjMgr_Append(mgr, (IUnknown *)&acl2->IACList_iface);
282 ok(hr == S_OK, "got 0x%08x\n", hr);
283 hr = IObjMgr_Append(mgr, NULL);
284 ok(hr == E_FAIL, "got 0x%08x\n", hr);
285 expect_str(obj, "a");
286 expect_str(obj, "c");
287 expect_str(obj, "e");
288 expect_str(obj, "a");
289 expect_str(obj, "b");
290 expect_str(obj, "d");
291 expect_end(obj);
292
293 hr = IEnumString_Reset(obj);
294 ok(hr == S_OK, "got 0x%08x\n", hr);
295 ok(acl1->pos == 0, "acl1 not reset\n");
296 ok(acl2->pos == 0, "acl2 not reset\n");
297
298 hr = IACList_Expand(acl, exp);
299 ok(hr == S_OK, "got 0x%08x\n", hr);
300 ok(acl1->expcount == 1, "expcount - expected 1, got %d\n", acl1->expcount);
301 ok(acl2->expcount == 0 /* XP */ || acl2->expcount == 1 /* Vista */,
302 "expcount - expected 0 or 1, got %d\n", acl2->expcount);
303
304 hr = IEnumString_Next(obj, 15, wstrtab, &i);
305 ok(hr == S_OK, "got 0x%08x\n", hr);
306 ok(i == 1, "Expected i == 1, got %d\n", i);
307 CoTaskMemFree(wstrtab[0]);
308
309 hr = IEnumString_Next(obj, 15, wstrtab, &i);
310 ok(hr == S_OK, "got 0x%08x\n", hr);
311 CoTaskMemFree(wstrtab[0]);
312
313 hr = IEnumString_Next(obj, 15, wstrtab, &i);
314 ok(hr == S_OK, "got 0x%08x\n", hr);
315 CoTaskMemFree(wstrtab[0]);
316
317 hr = IEnumString_Next(obj, 15, wstrtab, &i);
318 ok(hr == S_OK, "got 0x%08x\n", hr);
319 CoTaskMemFree(wstrtab[0]);
320
321 hr = IACList_Expand(acl, exp);
322 ok(hr == S_OK, "got 0x%08x\n", hr);
323 ok(acl1->expcount == 2, "expcount - expected 1, got %d\n", acl1->expcount);
324 ok(acl2->expcount == 0 /* XP */ || acl2->expcount == 2 /* Vista */,
325 "expcount - expected 0 or 2, got %d\n", acl2->expcount);
326 acl1->expret = S_FALSE;
327 hr = IACList_Expand(acl, exp);
328 ok(hr == S_OK, "got 0x%08x\n", hr);
329 ok(acl1->expcount == 3, "expcount - expected 1, got %d\n", acl1->expcount);
330 ok(acl2->expcount == 1 /* XP */ || acl2->expcount == 3 /* Vista */,
331 "expcount - expected 0 or 3, got %d\n", acl2->expcount);
332 acl1->expret = E_NOTIMPL;
333 hr = IACList_Expand(acl, exp);
334 ok(hr == S_OK, "got 0x%08x\n", hr);
335 ok(acl1->expcount == 4, "expcount - expected 1, got %d\n", acl1->expcount);
336 ok(acl2->expcount == 2 /* XP */ || acl2->expcount == 4 /* Vista */,
337 "expcount - expected 0 or 4, got %d\n", acl2->expcount);
338 acl2->expret = E_OUTOFMEMORY;
339 hr = IACList_Expand(acl, exp);
340 ok(hr == E_OUTOFMEMORY, "got 0x%08x\n", hr);
341 acl2->expret = E_FAIL;
342 hr = IACList_Expand(acl, exp);
343 ok(hr == E_FAIL, "got 0x%08x\n", hr);
344
345 hr = IObjMgr_Remove(mgr, (IUnknown *)&acl1->IACList_iface);
346 ok(hr == S_OK, "got 0x%08x\n", hr);
347
348 ok(acl1->ref == 1, "acl1 not released\n");
349 expect_end(obj);
350 IEnumString_Reset(obj);
351 expect_str(obj, "a");
352 expect_str(obj, "b");
353 expect_str(obj, "d");
354 expect_end(obj);
355
356 IEnumString_Release(obj);
357 IACList_Release(acl);
358 ref = IObjMgr_Release(mgr);
359 ok(ref == 0, "Unexpected references\n");
360 ok(acl1->ref == 1, "acl1 not released\n");
361 ok(acl2->ref == 1, "acl2 not released\n");
362
363 CoTaskMemFree(acl1);
364 CoTaskMemFree(acl2);
365 }
366
367 static void test_ACListISF(void)
368 {
369 IEnumString *enumstring;
370 IACList *list, *list2;
371 HRESULT hr;
372
373 hr = CoCreateInstance(&CLSID_ACListISF, NULL, CLSCTX_INPROC, &IID_IACList, (void**)&list);
374 ok(hr == S_OK, "failed to create ACListISF instance, 0x%08x\n", hr);
375
376 hr = IACList_QueryInterface(list, &IID_IEnumString, (void**)&enumstring);
377 ok(hr == S_OK, "got 0x%08x\n", hr);
378
379 hr = IEnumString_QueryInterface(enumstring, &IID_IACList, (void**)&list2);
380 ok(hr == S_OK, "got 0x%08x\n", hr);
381 ok(list == list2, "got %p, %p\n", list, list2);
382 IACList_Release(list2);
383
384 IEnumString_Release(enumstring);
385 IACList_Release(list);
386 }
387
388 START_TEST(autocomplete)
389 {
390 CoInitialize(NULL);
391
392 test_ACLMulti();
393 test_ACListISF();
394
395 CoUninitialize();
396 }