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 }
397