dlls/browseui/tests/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 }