dlls/atl100/tests/atl.c

   1 /*
   2  * Copyright 2012 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20 #include <stdio.h>
  21
  22 #define COBJMACROS
  23 #define CONST_VTABLE
  24
  25 #include <windef.h>
  26 #include <winbase.h>
  27 #include <winuser.h>
  28 #include <exdisp.h>
  29
  30 #include <atlbase.h>
  31 #include <mshtml.h>
  32
  33 #include <wine/test.h>
  34
  35 static const GUID CLSID_Test =
  36     {0x178fc163,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
  37 #define CLSID_TEST_STR "178fc163-0000-0000-0000-000000000046"
  38
  39 static const GUID CATID_CatTest1 =
  40     {0x178fc163,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x46}};
  41 #define CATID_CATTEST1_STR "178fc163-0000-0000-0000-000000000146"
  42
  43 static const GUID CATID_CatTest2 =
  44     {0x178fc163,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x46}};
  45 #define CATID_CATTEST2_STR "178fc163-0000-0000-0000-000000000246"
  46
  47 static const WCHAR emptyW[] = {'\0'};
  48 static const WCHAR randomW[] = {'r','a','n','d','o','m','\0'};
  49 static const WCHAR progid1W[] = {'S','h','e','l','l','.','E','x','p','l','o','r','e','r','.','2','\0'};
  50 static const WCHAR clsid1W[] = {'{','8','8','5','6','f','9','6','1','-','3','4','0','a','-',
  51                                 '1','1','d','0','-','a','9','6','b','-',
  52                                 '0','0','c','0','4','f','d','7','0','5','a','2','}','\0'};
  53 static const WCHAR url1W[] = {'h','t','t','p',':','/','/','t','e','s','t','.','w','i','n','e','h','q',
  54                               '.','o','r','g','/','t','e','s','t','s','/','w','i','n','e','h','q','_',
  55                               's','n','a','p','s','h','o','t','/','\0'};
  56 static const WCHAR mshtml1W[] = {'m','s','h','t','m','l',':','<','h','t','m','l','>','<','b','o','d','y','>',
  57                                  't','e','s','t','<','/','b','o','d','y','>','<','/','h','t','m','l','>','\0'};
  58 static const WCHAR mshtml2W[] = {'M','S','H','T','M','L',':','<','h','t','m','l','>','<','b','o','d','y','>',
  59                                  't','e','s','t','<','/','b','o','d','y','>','<','/','h','t','m','l','>','\0'};
  60 static const WCHAR mshtml3W[] = {'<','h','t','m','l','>','<','b','o','d','y','>', 't','e','s','t',
  61                                  '<','/','b','o','d','y','>','<','/','h','t','m','l','>','\0'};
  62 static const WCHAR fileW[] = {'f','i','l','e',':','/','/','/','\0'};
  63 static const WCHAR html_fileW[] = {'t','e','s','t','.','h','t','m','l','\0'};
  64 static const char html_str[] = "<html><body>test</body><html>";
  65
  66 static BOOL is_token_admin(HANDLE token)
  67 {
  68     PSID administrators = NULL;
  69     SID_IDENTIFIER_AUTHORITY nt_authority = { SECURITY_NT_AUTHORITY };
  70     DWORD groups_size;
  71     PTOKEN_GROUPS groups;
  72     DWORD group_index;
  73
  74     /* Create a well-known SID for the Administrators group. */
  75     if (! AllocateAndInitializeSid(&nt_authority, 2, SECURITY_BUILTIN_DOMAIN_RID,
  76                                    DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0,
  77                                    &administrators))
  78         return FALSE;
  79
  80     /* Get the group info from the token */
  81     groups_size = 0;
  82     GetTokenInformation(token, TokenGroups, NULL, 0, &groups_size);
  83     groups = HeapAlloc(GetProcessHeap(), 0, groups_size);
  84     if (groups == NULL)
  85     {
  86         FreeSid(administrators);
  87         return FALSE;
  88     }
  89     if (! GetTokenInformation(token, TokenGroups, groups, groups_size, &groups_size))
  90     {
  91         HeapFree(GetProcessHeap(), 0, groups);
  92         FreeSid(administrators);
  93         return FALSE;
  94     }
  95
  96     /* Now check if the token groups include the Administrators group */
  97     for (group_index = 0; group_index < groups->GroupCount; group_index++)
  98     {
  99         if (EqualSid(groups->Groups[group_index].Sid, administrators))
 100         {
 101             HeapFree(GetProcessHeap(), 0, groups);
 102             FreeSid(administrators);
 103             return TRUE;
 104         }
 105     }
 106
 107     /* If we end up here we didn't find the Administrators group */
 108     HeapFree(GetProcessHeap(), 0, groups);
 109     FreeSid(administrators);
 110     return FALSE;
 111 }
 112
 113 static BOOL is_process_limited(void)
 114 {
 115     static BOOL (WINAPI *pOpenProcessToken)(HANDLE, DWORD, PHANDLE) = NULL;
 116     HANDLE token;
 117     BOOL result=FALSE;
 118
 119     if (!pOpenProcessToken)
 120     {
 121         HMODULE hadvapi32 = GetModuleHandleA("advapi32.dll");
 122         pOpenProcessToken = (void*)GetProcAddress(hadvapi32, "OpenProcessToken");
 123         if (!pOpenProcessToken)
 124             return FALSE;
 125     }
 126
 127     if (pOpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token))
 128     {
 129         BOOL ret;
 130         TOKEN_ELEVATION_TYPE type = TokenElevationTypeDefault;
 131         DWORD size;
 132
 133         ret = GetTokenInformation(token, TokenElevationType, &type, sizeof(type), &size);
 134         if (ret)
 135         {
 136             if (type == TokenElevationTypeDefault)
 137                 /* UAC is disabled, check for administrators group */
 138                 result = !is_token_admin(token);
 139             else if (type == TokenElevationTypeFull)
 140                 result = FALSE;
 141             else if (type == TokenElevationTypeLimited)
 142                 result = TRUE;
 143         }
 144         CloseHandle(token);
 145     }
 146     return result;
 147 }
 148
 149 static void test_winmodule(void)
 150 {
 151     _AtlCreateWndData create_data[3];
 152     _ATL_WIN_MODULE winmod;
 153     void *p;
 154     HRESULT hres;
 155
 156     winmod.cbSize = 0xdeadbeef;
 157     hres = AtlWinModuleInit(&winmod);
 158     ok(hres == E_INVALIDARG, "AtlWinModuleInit failed: %08x\n", hres);
 159
 160     winmod.cbSize = sizeof(winmod);
 161     winmod.m_pCreateWndList = (void*)0xdeadbeef;
 162     winmod.m_csWindowCreate.LockCount = 0xdeadbeef;
 163     winmod.m_rgWindowClassAtoms.m_aT = (void*)0xdeadbeef;
 164     winmod.m_rgWindowClassAtoms.m_nSize = 0xdeadbeef;
 165     winmod.m_rgWindowClassAtoms.m_nAllocSize = 0xdeadbeef;
 166     hres = AtlWinModuleInit(&winmod);
 167     ok(hres == S_OK, "AtlWinModuleInit failed: %08x\n", hres);
 168     ok(!winmod.m_pCreateWndList, "winmod.m_pCreateWndList = %p\n", winmod.m_pCreateWndList);
 169     ok(winmod.m_csWindowCreate.LockCount == -1, "winmod.m_csWindowCreate.LockCount = %d\n",
 170        winmod.m_csWindowCreate.LockCount);
 171     ok(winmod.m_rgWindowClassAtoms.m_aT == (void*)0xdeadbeef, "winmod.m_rgWindowClassAtoms.m_aT = %p\n",
 172        winmod.m_rgWindowClassAtoms.m_aT);
 173     ok(winmod.m_rgWindowClassAtoms.m_nSize == 0xdeadbeef, "winmod.m_rgWindowClassAtoms.m_nSize = %d\n",
 174        winmod.m_rgWindowClassAtoms.m_nSize);
 175     ok(winmod.m_rgWindowClassAtoms.m_nAllocSize == 0xdeadbeef, "winmod.m_rgWindowClassAtoms.m_nAllocSize = %d\n",
 176        winmod.m_rgWindowClassAtoms.m_nAllocSize);
 177
 178     InitializeCriticalSection(&winmod.m_csWindowCreate);
 179
 180     AtlWinModuleAddCreateWndData(&winmod, create_data, (void*)0xdead0001);
 181     ok(winmod.m_pCreateWndList == create_data, "winmod.m_pCreateWndList != create_data\n");
 182     ok(create_data[0].m_pThis == (void*)0xdead0001, "unexpected create_data[0].m_pThis %p\n", create_data[0].m_pThis);
 183     ok(create_data[0].m_dwThreadID == GetCurrentThreadId(), "unexpected create_data[0].m_dwThreadID %x\n",
 184        create_data[0].m_dwThreadID);
 185     ok(!create_data[0].m_pNext, "unexpected create_data[0].m_pNext %p\n", create_data[0].m_pNext);
 186
 187     AtlWinModuleAddCreateWndData(&winmod, create_data+1, (void*)0xdead0002);
 188     ok(winmod.m_pCreateWndList == create_data+1, "winmod.m_pCreateWndList != create_data\n");
 189     ok(create_data[1].m_pThis == (void*)0xdead0002, "unexpected create_data[1].m_pThis %p\n", create_data[1].m_pThis);
 190     ok(create_data[1].m_dwThreadID == GetCurrentThreadId(), "unexpected create_data[1].m_dwThreadID %x\n",
 191        create_data[1].m_dwThreadID);
 192     ok(create_data[1].m_pNext == create_data, "unexpected create_data[1].m_pNext %p\n", create_data[1].m_pNext);
 193
 194     AtlWinModuleAddCreateWndData(&winmod, create_data+2, (void*)0xdead0003);
 195     ok(winmod.m_pCreateWndList == create_data+2, "winmod.m_pCreateWndList != create_data\n");
 196     ok(create_data[2].m_pThis == (void*)0xdead0003, "unexpected create_data[2].m_pThis %p\n", create_data[2].m_pThis);
 197     ok(create_data[2].m_dwThreadID == GetCurrentThreadId(), "unexpected create_data[2].m_dwThreadID %x\n",
 198        create_data[2].m_dwThreadID);
 199     ok(create_data[2].m_pNext == create_data+1, "unexpected create_data[2].m_pNext %p\n", create_data[2].m_pNext);
 200
 201     p = AtlWinModuleExtractCreateWndData(&winmod);
 202     ok(p == (void*)0xdead0003, "unexpected AtlWinModuleExtractCreateWndData result %p\n", p);
 203     ok(winmod.m_pCreateWndList == create_data+1, "winmod.m_pCreateWndList != create_data\n");
 204     ok(create_data[2].m_pNext == create_data+1, "unexpected create_data[2].m_pNext %p\n", create_data[2].m_pNext);
 205
 206     create_data[1].m_dwThreadID = 0xdeadbeef;
 207
 208     p = AtlWinModuleExtractCreateWndData(&winmod);
 209     ok(p == (void*)0xdead0001, "unexpected AtlWinModuleExtractCreateWndData result %p\n", p);
 210     ok(winmod.m_pCreateWndList == create_data+1, "winmod.m_pCreateWndList != create_data\n");
 211     ok(!create_data[0].m_pNext, "unexpected create_data[0].m_pNext %p\n", create_data[0].m_pNext);
 212     ok(!create_data[1].m_pNext, "unexpected create_data[1].m_pNext %p\n", create_data[1].m_pNext);
 213
 214     p = AtlWinModuleExtractCreateWndData(&winmod);
 215     ok(!p, "unexpected AtlWinModuleExtractCreateWndData result %p\n", p);
 216     ok(winmod.m_pCreateWndList == create_data+1, "winmod.m_pCreateWndList != create_data\n");
 217 }
 218
 219 #define test_key_exists(a,b) _test_key_exists(__LINE__,a,b)
 220 static void _test_key_exists(unsigned line, HKEY root, const char *key_name)
 221 {
 222     HKEY key;
 223     DWORD res;
 224
 225     res = RegOpenKeyA(root, key_name, &key);
 226     ok_(__FILE__,line)(res == ERROR_SUCCESS, "Could not open key %s\n", key_name);
 227     if(res == ERROR_SUCCESS)
 228         RegCloseKey(key);
 229 }
 230
 231 #define test_key_not_exists(a,b) _test_key_not_exists(__LINE__,a,b)
 232 static void _test_key_not_exists(unsigned line, HKEY root, const char *key_name)
 233 {
 234     HKEY key;
 235     DWORD res;
 236
 237     res = RegOpenKeyA(root, key_name, &key);
 238     ok_(__FILE__,line)(res == ERROR_FILE_NOT_FOUND, "Attempting to open %s returned %u\n", key_name, res);
 239     if(res == ERROR_SUCCESS)
 240         RegCloseKey(key);
 241 }
 242
 243 static void test_regcat(void)
 244 {
 245     unsigned char b;
 246     HRESULT hres;
 247
 248     const struct _ATL_CATMAP_ENTRY catmap[] = {
 249         {_ATL_CATMAP_ENTRY_IMPLEMENTED, &CATID_CatTest1},
 250         {_ATL_CATMAP_ENTRY_REQUIRED, &CATID_CatTest2},
 251         {_ATL_CATMAP_ENTRY_END}
 252     };
 253
 254     if (is_process_limited())
 255     {
 256         skip("process is limited\n");
 257         return;
 258     }
 259
 260     hres = AtlRegisterClassCategoriesHelper(&CLSID_Test, catmap, TRUE);
 261     ok(hres == S_OK, "AtlRegisterClassCategoriesHelper failed: %08x\n", hres);
 262
 263     test_key_exists(HKEY_CLASSES_ROOT, "CLSID\\{" CLSID_TEST_STR "}");
 264     test_key_exists(HKEY_CLASSES_ROOT, "CLSID\\{" CLSID_TEST_STR "}\\Implemented Categories\\{" CATID_CATTEST1_STR "}");
 265     test_key_exists(HKEY_CLASSES_ROOT, "CLSID\\{" CLSID_TEST_STR "}\\Required Categories\\{" CATID_CATTEST2_STR "}");
 266
 267     hres = AtlRegisterClassCategoriesHelper(&CLSID_Test, catmap, FALSE);
 268     ok(hres == S_OK, "AtlRegisterClassCategoriesHelper failed: %08x\n", hres);
 269
 270     test_key_not_exists(HKEY_CLASSES_ROOT, "CLSID\\{" CLSID_TEST_STR "}\\Implemented Categories");
 271     test_key_not_exists(HKEY_CLASSES_ROOT, "CLSID\\{" CLSID_TEST_STR "}\\Required Categories");
 272     test_key_exists(HKEY_CLASSES_ROOT, "CLSID\\{" CLSID_TEST_STR "}");
 273
 274     ok(RegDeleteKeyA(HKEY_CLASSES_ROOT, "CLSID\\{" CLSID_TEST_STR "}") == ERROR_SUCCESS, "Could not delete key\n");
 275
 276     hres = AtlRegisterClassCategoriesHelper(&CLSID_Test, NULL, TRUE);
 277     ok(hres == S_OK, "AtlRegisterClassCategoriesHelper failed: %08x\n", hres);
 278
 279     test_key_not_exists(HKEY_CLASSES_ROOT, "CLSID\\{" CLSID_TEST_STR "}");
 280
 281     b = 10;
 282     hres = AtlGetPerUserRegistration(&b);
 283     ok(hres == S_OK, "AtlGetPerUserRegistration failed: %08x\n", hres);
 284     ok(!b, "AtlGetPerUserRegistration returned %x\n", b);
 285 }
 286
 287 static void test_typelib(void)
 288 {
 289     ITypeLib *typelib;
 290     HINSTANCE inst;
 291     size_t len;
 292     BSTR path;
 293     HRESULT hres;
 294
 295     static const WCHAR scrrun_dll_suffixW[] = {'\\','s','c','r','r','u','n','.','d','l','l',0};
 296     static const WCHAR mshtml_tlb_suffixW[] = {'\\','m','s','h','t','m','l','.','t','l','b',0};
 297
 298     inst = LoadLibraryA("scrrun.dll");
 299     ok(inst != NULL, "Could not load scrrun.dll\n");
 300
 301     typelib = NULL;
 302     hres = AtlLoadTypeLib(inst, NULL, &path, &typelib);
 303     ok(hres == S_OK, "AtlLoadTypeLib failed: %08x\n", hres);
 304     FreeLibrary(inst);
 305
 306     len = SysStringLen(path);
 307     ok(len > sizeof(scrrun_dll_suffixW)/sizeof(WCHAR)
 308        && lstrcmpiW(path+len-sizeof(scrrun_dll_suffixW)/sizeof(WCHAR), scrrun_dll_suffixW),
 309        "unexpected path %s\n", wine_dbgstr_w(path));
 310     SysFreeString(path);
 311     ok(typelib != NULL, "typelib == NULL\n");
 312     ITypeLib_Release(typelib);
 313
 314     inst = LoadLibraryA("mshtml.dll");
 315     ok(inst != NULL, "Could not load mshtml.dll\n");
 316
 317     typelib = NULL;
 318     hres = AtlLoadTypeLib(inst, NULL, &path, &typelib);
 319     ok(hres == S_OK, "AtlLoadTypeLib failed: %08x\n", hres);
 320     FreeLibrary(inst);
 321
 322     len = SysStringLen(path);
 323     ok(len > sizeof(mshtml_tlb_suffixW)/sizeof(WCHAR)
 324        && lstrcmpiW(path+len-sizeof(mshtml_tlb_suffixW)/sizeof(WCHAR), mshtml_tlb_suffixW),
 325        "unexpected path %s\n", wine_dbgstr_w(path));
 326     SysFreeString(path);
 327     ok(typelib != NULL, "typelib == NULL\n");
 328     ITypeLib_Release(typelib);
 329 }
 330
 331 static HRESULT WINAPI ConnectionPoint_QueryInterface(IConnectionPoint *iface, REFIID riid, void **ppv)
 332 {
 333     if(IsEqualGUID(&IID_IConnectionPoint, riid)) {
 334         *ppv = iface;
 335         return S_OK;
 336     }
 337
 338     ok(0, "unexpected call\n");
 339     return E_NOINTERFACE;
 340 }
 341
 342 static ULONG WINAPI ConnectionPoint_AddRef(IConnectionPoint *iface)
 343 {
 344     return 2;
 345 }
 346
 347 static ULONG WINAPI ConnectionPoint_Release(IConnectionPoint *iface)
 348 {
 349     return 1;
 350 }
 351
 352 static HRESULT WINAPI ConnectionPoint_GetConnectionInterface(IConnectionPoint *iface, IID *pIID)
 353 {
 354     ok(0, "unexpected call\n");
 355     return E_NOTIMPL;
 356 }
 357
 358 static HRESULT WINAPI ConnectionPoint_GetConnectionPointContainer(IConnectionPoint *iface,
 359         IConnectionPointContainer **ppCPC)
 360 {
 361     ok(0, "unexpected call\n");
 362     return E_NOTIMPL;
 363 }
 364
 365 static int advise_cnt;
 366
 367 static HRESULT WINAPI ConnectionPoint_Advise(IConnectionPoint *iface, IUnknown *pUnkSink,
 368                                              DWORD *pdwCookie)
 369 {
 370     ok(pUnkSink == (IUnknown*)0xdead0000, "pUnkSink = %p\n", pUnkSink);
 371     *pdwCookie = 0xdeadbeef;
 372     advise_cnt++;
 373     return S_OK;
 374 }
 375
 376 static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD dwCookie)
 377 {
 378     ok(dwCookie == 0xdeadbeef, "dwCookie = %x\n", dwCookie);
 379     advise_cnt--;
 380     return S_OK;
 381 }
 382
 383 static HRESULT WINAPI ConnectionPoint_EnumConnections(IConnectionPoint *iface,
 384                                                       IEnumConnections **ppEnum)
 385 {
 386     ok(0, "unexpected call\n");
 387     return E_NOTIMPL;
 388 }
 389
 390 static const IConnectionPointVtbl ConnectionPointVtbl =
 391 {
 392     ConnectionPoint_QueryInterface,
 393     ConnectionPoint_AddRef,
 394     ConnectionPoint_Release,
 395     ConnectionPoint_GetConnectionInterface,
 396     ConnectionPoint_GetConnectionPointContainer,
 397     ConnectionPoint_Advise,
 398     ConnectionPoint_Unadvise,
 399     ConnectionPoint_EnumConnections
 400 };
 401
 402 static IConnectionPoint ConnectionPoint = { &ConnectionPointVtbl };
 403
 404 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface,
 405         REFIID riid, void **ppv)
 406 {
 407     if(IsEqualGUID(&IID_IConnectionPointContainer, riid)) {
 408         *ppv = iface;
 409         return S_OK;
 410     }
 411
 412     ok(0, "unexpected call\n");
 413     return E_NOTIMPL;
 414 }
 415
 416 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
 417 {
 418     return 2;
 419 }
 420
 421 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
 422 {
 423     return 1;
 424 }
 425
 426 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
 427         IEnumConnectionPoints **ppEnum)
 428 {
 429     ok(0, "unexpected call\n");
 430     return E_NOTIMPL;
 431 }
 432
 433 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
 434         REFIID riid, IConnectionPoint **ppCP)
 435 {
 436     ok(IsEqualGUID(riid, &CLSID_Test), "unexpected riid\n");
 437     *ppCP = &ConnectionPoint;
 438     return S_OK;
 439 }
 440
 441 static const IConnectionPointContainerVtbl ConnectionPointContainerVtbl = {
 442     ConnectionPointContainer_QueryInterface,
 443     ConnectionPointContainer_AddRef,
 444     ConnectionPointContainer_Release,
 445     ConnectionPointContainer_EnumConnectionPoints,
 446     ConnectionPointContainer_FindConnectionPoint
 447 };
 448
 449 static IConnectionPointContainer ConnectionPointContainer = { &ConnectionPointContainerVtbl };
 450
 451 static void test_cp(void)
 452 {
 453     DWORD cookie = 0;
 454     HRESULT hres;
 455
 456     hres = AtlAdvise(NULL, (IUnknown*)0xdeed0000, &CLSID_Test, &cookie);
 457     ok(hres == E_INVALIDARG, "expect E_INVALIDARG, returned %08x\n", hres);
 458
 459     hres = AtlUnadvise(NULL, &CLSID_Test, 0xdeadbeef);
 460     ok(hres == E_INVALIDARG, "expect E_INVALIDARG, returned %08x\n", hres);
 461
 462     hres = AtlAdvise((IUnknown*)&ConnectionPointContainer, (IUnknown*)0xdead0000, &CLSID_Test, &cookie);
 463     ok(hres == S_OK, "AtlAdvise failed: %08x\n", hres);
 464     ok(cookie == 0xdeadbeef, "cookie = %x\n", cookie);
 465     ok(advise_cnt == 1, "advise_cnt = %d\n", advise_cnt);
 466
 467     hres = AtlUnadvise((IUnknown*)&ConnectionPointContainer, &CLSID_Test, 0xdeadbeef);
 468     ok(hres == S_OK, "AtlUnadvise failed: %08x\n", hres);
 469     ok(!advise_cnt, "advise_cnt = %d\n", advise_cnt);
 470 }
 471
 472 static CLSID persist_clsid;
 473
 474 static HRESULT WINAPI Persist_QueryInterface(IPersist *iface, REFIID riid, void **ppv)
 475 {
 476     ok(0, "unexpected call\n");
 477     return E_NOINTERFACE;
 478 }
 479
 480 static ULONG WINAPI Persist_AddRef(IPersist *iface)
 481 {
 482     return 2;
 483 }
 484
 485 static ULONG WINAPI Persist_Release(IPersist *iface)
 486 {
 487     return 1;
 488 }
 489
 490 static HRESULT WINAPI Persist_GetClassID(IPersist *iface, CLSID *pClassID)
 491 {
 492     *pClassID = persist_clsid;
 493     return S_OK;
 494 }
 495
 496 static const IPersistVtbl PersistVtbl = {
 497     Persist_QueryInterface,
 498     Persist_AddRef,
 499     Persist_Release,
 500     Persist_GetClassID
 501 };
 502
 503 static IPersist Persist = { &PersistVtbl };
 504
 505 static HRESULT WINAPI ProvideClassInfo2_QueryInterface(IProvideClassInfo2 *iface, REFIID riid, void **ppv)
 506 {
 507     ok(0, "unexpected call\n");
 508     return E_NOINTERFACE;
 509 }
 510
 511 static ULONG WINAPI ProvideClassInfo2_AddRef(IProvideClassInfo2 *iface)
 512 {
 513     return 2;
 514 }
 515
 516 static ULONG WINAPI ProvideClassInfo2_Release(IProvideClassInfo2 *iface)
 517 {
 518     return 1;
 519 }
 520
 521 static HRESULT WINAPI ProvideClassInfo2_GetClassInfo(IProvideClassInfo2 *iface, ITypeInfo **ppTI)
 522 {
 523     ok(0, "unexpected call\n");
 524     return E_NOTIMPL;
 525 }
 526
 527 static HRESULT WINAPI ProvideClassInfo2_GetGUID(IProvideClassInfo2 *iface, DWORD dwGuidKind, GUID *pGUID)
 528 {
 529     ok(dwGuidKind == GUIDKIND_DEFAULT_SOURCE_DISP_IID, "unexpected dwGuidKind %x\n", dwGuidKind);
 530     *pGUID = DIID_DispHTMLBody;
 531     return S_OK;
 532 }
 533
 534 static const IProvideClassInfo2Vtbl ProvideClassInfo2Vtbl = {
 535     ProvideClassInfo2_QueryInterface,
 536     ProvideClassInfo2_AddRef,
 537     ProvideClassInfo2_Release,
 538     ProvideClassInfo2_GetClassInfo,
 539     ProvideClassInfo2_GetGUID
 540 };
 541
 542 static IProvideClassInfo2 ProvideClassInfo2 = { &ProvideClassInfo2Vtbl };
 543 static BOOL support_classinfo2;
 544
 545 static HRESULT WINAPI Dispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
 546 {
 547     *ppv = NULL;
 548
 549     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IDispatch, riid)) {
 550         *ppv = iface;
 551         return S_OK;
 552     }
 553
 554     if(IsEqualGUID(&IID_IProvideClassInfo2, riid)) {
 555         if(!support_classinfo2)
 556             return E_NOINTERFACE;
 557         *ppv = &ProvideClassInfo2;
 558         return S_OK;
 559     }
 560
 561     if(IsEqualGUID(&IID_IPersist, riid)) {
 562         *ppv = &Persist;
 563         return S_OK;
 564     }
 565
 566     ok(0, "unexpected riid: %s\n", wine_dbgstr_guid(riid));
 567     return E_NOINTERFACE;
 568 }
 569
 570 static ULONG WINAPI Dispatch_AddRef(IDispatch *iface)
 571 {
 572     return 2;
 573 }
 574
 575 static ULONG WINAPI Dispatch_Release(IDispatch *iface)
 576 {
 577     return 1;
 578 }
 579
 580 static HRESULT WINAPI Dispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 581 {
 582     ok(0, "unexpected call\n");
 583     return E_NOTIMPL;
 584 }
 585
 586 static HRESULT WINAPI Dispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid,
 587         ITypeInfo **ppTInfo)
 588 {
 589     ITypeLib *typelib;
 590     HRESULT hres;
 591
 592     static const WCHAR mshtml_tlbW[] = {'m','s','h','t','m','l','.','t','l','b',0};
 593
 594     ok(!iTInfo, "iTInfo = %d\n", iTInfo);
 595     ok(!lcid, "lcid = %x\n", lcid);
 596
 597     hres = LoadTypeLib(mshtml_tlbW, &typelib);
 598     ok(hres == S_OK, "LoadTypeLib failed: %08x\n", hres);
 599
 600     hres = ITypeLib_GetTypeInfoOfGuid(typelib, &IID_IHTMLElement, ppTInfo);
 601     ok(hres == S_OK, "GetTypeInfoOfGuid failed: %08x\n", hres);
 602
 603     ITypeLib_Release(typelib);
 604     return S_OK;
 605 }
 606
 607 static HRESULT WINAPI Dispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
 608         UINT cNames, LCID lcid, DISPID *rgDispId)
 609 {
 610     ok(0, "unexpected call\n");
 611     return E_NOTIMPL;
 612 }
 613
 614 static HRESULT WINAPI Dispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
 615         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 616         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 617 {
 618     ok(0, "unexpected call\n");
 619     return E_NOTIMPL;
 620 }
 621
 622 static const IDispatchVtbl DispatchVtbl = {
 623     Dispatch_QueryInterface,
 624     Dispatch_AddRef,
 625     Dispatch_Release,
 626     Dispatch_GetTypeInfoCount,
 627     Dispatch_GetTypeInfo,
 628     Dispatch_GetIDsOfNames,
 629     Dispatch_Invoke
 630 };
 631
 632 static IDispatch Dispatch = { &DispatchVtbl };
 633
 634 static void test_source_iface(void)
 635 {
 636     unsigned short maj_ver, min_ver;
 637     IID libid, iid;
 638     HRESULT hres;
 639
 640     support_classinfo2 = TRUE;
 641
 642     maj_ver = min_ver = 0xdead;
 643     hres = AtlGetObjectSourceInterface((IUnknown*)&Dispatch, &libid, &iid, &maj_ver, &min_ver);
 644     ok(hres == S_OK, "AtlGetObjectSourceInterface failed: %08x\n", hres);
 645     ok(IsEqualGUID(&libid, &LIBID_MSHTML), "libid = %s\n", wine_dbgstr_guid(&libid));
 646     ok(IsEqualGUID(&iid, &DIID_DispHTMLBody), "iid = %s\n", wine_dbgstr_guid(&iid));
 647     ok(maj_ver == 4 && min_ver == 0, "ver = %d.%d\n", maj_ver, min_ver);
 648
 649     support_classinfo2 = FALSE;
 650     persist_clsid = CLSID_HTMLDocument;
 651
 652     maj_ver = min_ver = 0xdead;
 653     hres = AtlGetObjectSourceInterface((IUnknown*)&Dispatch, &libid, &iid, &maj_ver, &min_ver);
 654     ok(hres == S_OK, "AtlGetObjectSourceInterface failed: %08x\n", hres);
 655     ok(IsEqualGUID(&libid, &LIBID_MSHTML), "libid = %s\n", wine_dbgstr_guid(&libid));
 656     ok(IsEqualGUID(&iid, &DIID_HTMLDocumentEvents), "iid = %s\n", wine_dbgstr_guid(&iid));
 657     ok(maj_ver == 4 && min_ver == 0, "ver = %d.%d\n", maj_ver, min_ver);
 658
 659     persist_clsid = CLSID_HTMLStyle;
 660
 661     maj_ver = min_ver = 0xdead;
 662     hres = AtlGetObjectSourceInterface((IUnknown*)&Dispatch, &libid, &iid, &maj_ver, &min_ver);
 663     ok(hres == S_OK, "AtlGetObjectSourceInterface failed: %08x\n", hres);
 664     ok(IsEqualGUID(&libid, &LIBID_MSHTML), "libid = %s\n", wine_dbgstr_guid(&libid));
 665     ok(IsEqualGUID(&iid, &IID_NULL), "iid = %s\n", wine_dbgstr_guid(&iid));
 666     ok(maj_ver == 4 && min_ver == 0, "ver = %d.%d\n", maj_ver, min_ver);
 667 }
 668
 669 static void test_ax_win(void)
 670 {
 671     DWORD ret, ret_size, i;
 672     HRESULT res;
 673     HWND hwnd;
 674     HANDLE hfile;
 675     IUnknown *control;
 676     WNDPROC wndproc[2] = {NULL, NULL};
 677     WCHAR file_uri1W[MAX_PATH], pathW[MAX_PATH];
 678     WNDCLASSEXW wcex;
 679     static HMODULE hinstance = 0;
 680     static const WCHAR cls_names[][16] =
 681     {
 682         {'A','t','l','A','x','W','i','n','1','0','0',0},
 683         {'A','t','l','A','x','W','i','n','L','i','c','1','0','0',0}
 684     };
 685
 686     ret = AtlAxWinInit();
 687     ok(ret, "AtlAxWinInit failed\n");
 688
 689     hinstance = GetModuleHandleA(NULL);
 690
 691     for (i = 0; i < 2; i++)
 692     {
 693         memset(&wcex, 0, sizeof(wcex));
 694         wcex.cbSize = sizeof(wcex);
 695         ret = GetClassInfoExW(hinstance, cls_names[i], &wcex);
 696         ok(ret, "%s has not registered\n", wine_dbgstr_w(cls_names[i]));
 697         ok(wcex.style == (CS_GLOBALCLASS | CS_DBLCLKS), "wcex.style %08x\n", wcex.style);
 698         wndproc[i] = wcex.lpfnWndProc;
 699
 700         hwnd = CreateWindowW(cls_names[i], NULL, 0, 100, 100, 100, 100, NULL, NULL, NULL, NULL);
 701         ok(hwnd != NULL, "CreateWindow failed!\n");
 702         control = (IUnknown *)0xdeadbeef;
 703         res = AtlAxGetControl(hwnd, &control);
 704         ok(res == E_FAIL, "Expected E_FAIL, returned %08x\n", res);
 705         ok(!control, "returned %p\n", control);
 706         if (control) IUnknown_Release(control);
 707         DestroyWindow(hwnd);
 708
 709         hwnd = CreateWindowW(cls_names[i], emptyW, 0, 100, 100, 100, 100, NULL, NULL, NULL, NULL);
 710         ok(hwnd != NULL, "CreateWindow failed!\n");
 711         control = (IUnknown *)0xdeadbeef;
 712         res = AtlAxGetControl(hwnd, &control);
 713         ok(res == E_FAIL, "Expected E_FAIL, returned %08x\n", res);
 714         ok(!control, "returned %p\n", control);
 715         if (control) IUnknown_Release(control);
 716         DestroyWindow(hwnd);
 717
 718         hwnd = CreateWindowW(cls_names[i], randomW, 0, 100, 100, 100, 100, NULL, NULL, NULL, NULL);
 719         todo_wine ok(!hwnd, "returned %p\n", hwnd);
 720         if(hwnd) DestroyWindow(hwnd);
 721
 722         hwnd = CreateWindowW(cls_names[i], progid1W, 0, 100, 100, 100, 100, NULL, NULL, NULL, NULL);
 723         ok(hwnd != NULL, "CreateWindow failed!\n");
 724         control = NULL;
 725         res = AtlAxGetControl(hwnd, &control);
 726         ok(res == S_OK, "AtlAxGetControl failed with res %08x\n", res);
 727         ok(control != NULL, "AtlAxGetControl failed!\n");
 728         IUnknown_Release(control);
 729         DestroyWindow(hwnd);
 730
 731         hwnd = CreateWindowW(cls_names[i], clsid1W, 0, 100, 100, 100, 100, NULL, NULL, NULL, NULL);
 732         ok(hwnd != NULL, "CreateWindow failed!\n");
 733         control = NULL;
 734         res = AtlAxGetControl(hwnd, &control);
 735         ok(res == S_OK, "AtlAxGetControl failed with res %08x\n", res);
 736         ok(control != NULL, "AtlAxGetControl failed!\n");
 737         IUnknown_Release(control);
 738         DestroyWindow(hwnd);
 739
 740         hwnd = CreateWindowW(cls_names[i], url1W, 0, 100, 100, 100, 100, NULL, NULL, NULL, NULL);
 741         ok(hwnd != NULL, "CreateWindow failed!\n");
 742         control = NULL;
 743         res = AtlAxGetControl(hwnd, &control);
 744         ok(res == S_OK, "AtlAxGetControl failed with res %08x\n", res);
 745         ok(control != NULL, "AtlAxGetControl failed!\n");
 746         IUnknown_Release(control);
 747         DestroyWindow(hwnd);
 748
 749         /* test html stream with "MSHTML:" prefix */
 750         hwnd = CreateWindowW(cls_names[i], mshtml1W, 0, 100, 100, 100, 100, NULL, NULL, NULL, NULL);
 751         ok(hwnd != NULL, "CreateWindow failed!\n");
 752         control = NULL;
 753         res = AtlAxGetControl(hwnd, &control);
 754         ok(res == S_OK, "AtlAxGetControl failed with res %08x\n", res);
 755         ok(control != NULL, "AtlAxGetControl failed!\n");
 756         IUnknown_Release(control);
 757         DestroyWindow(hwnd);
 758
 759         hwnd = CreateWindowW(cls_names[i], mshtml2W, 0, 100, 100, 100, 100, NULL, NULL, NULL, NULL);
 760         ok(hwnd != NULL, "CreateWindow failed!\n");
 761         control = NULL;
 762         res = AtlAxGetControl(hwnd, &control);
 763         ok(res == S_OK, "AtlAxGetControl failed with res %08x\n", res);
 764         ok(control != NULL, "AtlAxGetControl failed!\n");
 765         IUnknown_Release(control);
 766         DestroyWindow(hwnd);
 767
 768         /* test html stream without "MSHTML:" prefix */
 769         hwnd = CreateWindowW(cls_names[i], mshtml3W, 0, 100, 100, 100, 100, NULL, NULL, NULL, NULL);
 770         todo_wine ok(!hwnd, "returned %p\n", hwnd);
 771         if(hwnd) DestroyWindow(hwnd);
 772
 773         ret = GetTempPathW(MAX_PATH, pathW);
 774         ok(ret, "GetTempPath failed!\n");
 775         lstrcatW(pathW, html_fileW);
 776         hfile = CreateFileW(pathW, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, 0);
 777         ok(hfile != INVALID_HANDLE_VALUE, "failed to create file\n");
 778         ret = WriteFile(hfile, html_str, sizeof(html_str), &ret_size, NULL);
 779         ok(ret, "WriteFile failed\n");
 780         CloseHandle(hfile);
 781
 782         /* test C:// scheme */
 783         hwnd = CreateWindowW(cls_names[i], pathW, 0, 100, 100, 100, 100, NULL, NULL, NULL, NULL);
 784         ok(hwnd != NULL, "CreateWindow failed!\n");
 785         control = NULL;
 786         res = AtlAxGetControl(hwnd, &control);
 787         ok(res == S_OK, "AtlAxGetControl failed with res %08x\n", res);
 788         ok(control != NULL, "AtlAxGetControl failed!\n");
 789         IUnknown_Release(control);
 790         DestroyWindow(hwnd);
 791
 792         /* test file:// scheme */
 793         lstrcpyW(file_uri1W, fileW);
 794         lstrcatW(file_uri1W, pathW);
 795         hwnd = CreateWindowW(cls_names[i], file_uri1W, 0, 100, 100, 100, 100, NULL, NULL, NULL, NULL);
 796         ok(hwnd != NULL, "CreateWindow failed!\n");
 797         control = NULL;
 798         res = AtlAxGetControl(hwnd, &control);
 799         ok(res == S_OK, "AtlAxGetControl failed with res %08x\n", res);
 800         ok(control != NULL, "AtlAxGetControl failed!\n");
 801         IUnknown_Release(control);
 802         DestroyWindow(hwnd);
 803
 804         /* test file:// scheme on non-existent file */
 805         ret = DeleteFileW(pathW);
 806         ok(ret, "DeleteFile failed!\n");
 807         hwnd = CreateWindowW(cls_names[i], file_uri1W, 0, 100, 100, 100, 100, NULL, NULL, NULL, NULL);
 808         ok(hwnd != NULL, "CreateWindow failed!\n");
 809         control = NULL;
 810         res = AtlAxGetControl(hwnd, &control);
 811         ok(res == S_OK, "AtlAxGetControl failed with res %08x\n", res);
 812         ok(control != NULL, "AtlAxGetControl failed!\n");
 813         IUnknown_Release(control);
 814         DestroyWindow(hwnd);
 815     }
 816     todo_wine ok(wndproc[0] != wndproc[1], "expected different proc!\n");
 817 }
 818
 819 static ATOM register_class(void)
 820 {
 821     WNDCLASSA wndclassA;
 822
 823     wndclassA.style = 0;
 824     wndclassA.lpfnWndProc = DefWindowProcA;
 825     wndclassA.cbClsExtra = 0;
 826     wndclassA.cbWndExtra = 0;
 827     wndclassA.hInstance = GetModuleHandleA(NULL);
 828     wndclassA.hIcon = NULL;
 829     wndclassA.hCursor = LoadCursorA(NULL, (LPSTR)IDC_ARROW);
 830     wndclassA.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
 831     wndclassA.lpszMenuName = NULL;
 832     wndclassA.lpszClassName = "WineAtlTestClass";
 833
 834     return RegisterClassA(&wndclassA);
 835 }
 836
 837 static HWND create_container_window(void)
 838 {
 839     return CreateWindowA("WineAtlTestClass", "Wine ATL Test Window", 0,
 840                               CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 841                               CW_USEDEFAULT, NULL, NULL, NULL, NULL);
 842 }
 843
 844 static void test_AtlAxAttachControl(void)
 845 {
 846     HWND hwnd;
 847     HRESULT hr;
 848     IUnknown *control, *container;
 849     LONG val;
 850
 851     hr = AtlAxAttachControl(NULL, NULL, NULL);
 852     ok(hr == E_INVALIDARG, "Expected AtlAxAttachControl to return E_INVALIDARG, got 0x%08x\n", hr);
 853
 854     container = (IUnknown *)0xdeadbeef;
 855     hr = AtlAxAttachControl(NULL, NULL, &container);
 856     ok(hr == E_INVALIDARG, "Expected AtlAxAttachControl to return E_INVALIDARG, got 0x%08x\n", hr);
 857     ok(container == (IUnknown *)0xdeadbeef,
 858        "Expected the output container pointer to be untouched, got %p\n", container);
 859
 860     hwnd = create_container_window();
 861     hr = AtlAxAttachControl(NULL, hwnd, NULL);
 862     ok(hr == E_INVALIDARG, "Expected AtlAxAttachControl to return E_INVALIDARG, got 0x%08x\n", hr);
 863     DestroyWindow(hwnd);
 864
 865     hwnd = create_container_window();
 866     container = (IUnknown *)0xdeadbeef;
 867     hr = AtlAxAttachControl(NULL, hwnd, &container);
 868     ok(hr == E_INVALIDARG, "Expected AtlAxAttachControl to return E_INVALIDARG, got 0x%08x\n", hr);
 869     ok(container == (IUnknown *)0xdeadbeef, "returned %p\n", container);
 870     DestroyWindow(hwnd);
 871
 872     hr = CoCreateInstance(&CLSID_WebBrowser, NULL, CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER,
 873                           &IID_IOleObject, (void **)&control);
 874     ok(hr == S_OK, "Expected CoCreateInstance to return S_OK, got 0x%08x\n", hr);
 875
 876     if (FAILED(hr))
 877     {
 878         skip("Couldn't obtain a test IOleObject instance\n");
 879         return;
 880     }
 881
 882     hr = AtlAxAttachControl(control, NULL, NULL);
 883     ok(hr == S_FALSE, "Expected AtlAxAttachControl to return S_FALSE, got 0x%08x\n", hr);
 884
 885     container = NULL;
 886     hr = AtlAxAttachControl(control, NULL, &container);
 887     ok(hr == S_FALSE, "Expected AtlAxAttachControl to return S_FALSE, got 0x%08x\n", hr);
 888     ok(container != NULL, "got %p\n", container);
 889     IUnknown_Release(container);
 890
 891     hwnd = create_container_window();
 892     SetWindowLongW(hwnd, GWLP_USERDATA, 0xdeadbeef);
 893     hr = AtlAxAttachControl(control, hwnd, NULL);
 894     ok(hr == S_OK, "Expected AtlAxAttachControl to return S_OK, got 0x%08x\n", hr);
 895     val = GetWindowLongW(hwnd, GWLP_USERDATA);
 896     ok(val == 0xdeadbeef, "returned %08x\n", val);
 897     DestroyWindow(hwnd);
 898
 899     hwnd = create_container_window();
 900     SetWindowLongW(hwnd, GWLP_USERDATA, 0xdeadbeef);
 901     container = NULL;
 902     hr = AtlAxAttachControl(control, hwnd, &container);
 903     ok(hr == S_OK, "Expected AtlAxAttachControl to return S_OK, got 0x%08x\n", hr);
 904     ok(container != NULL, "Expected not NULL!\n");
 905     val = GetWindowLongW(hwnd, GWLP_USERDATA);
 906     ok(val == 0xdeadbeef, "Expected unchanged, returned %08x\n", val);
 907     DestroyWindow(hwnd);
 908
 909     IUnknown_Release(control);
 910 }
 911
 912 static void test_AtlAxCreateControl(void)
 913 {
 914     HWND hwnd;
 915     IUnknown *control, *container;
 916     HRESULT hr;
 917     DWORD ret, ret_size;
 918     HANDLE hfile;
 919     WCHAR file_uri1W[MAX_PATH], pathW[MAX_PATH];
 920
 921     container = NULL;
 922     control = (IUnknown *)0xdeadbeef;
 923     hr = AtlAxCreateControlEx(NULL, NULL, NULL, &container, &control, NULL, NULL);
 924     todo_wine ok(hr == S_FALSE, "got 0x%08x\n", hr);
 925     todo_wine ok(container != NULL, "returned %p\n", container);
 926     ok(!control, "returned %p\n", control);
 927
 928     container = NULL;
 929     control = (IUnknown *)0xdeadbeef;
 930     hwnd = create_container_window();
 931     ok(hwnd != NULL, "create window failed!\n");
 932     hr = AtlAxCreateControlEx(NULL, hwnd, NULL, &container, &control, &IID_NULL, NULL);
 933     ok(hr == S_OK, "got 0x%08x\n", hr);
 934     todo_wine ok(container != NULL, "returned %p!\n", container);
 935     ok(!control, "returned %p\n", control);
 936     DestroyWindow(hwnd);
 937
 938     container = NULL;
 939     control = (IUnknown *)0xdeadbeef;
 940     hwnd = create_container_window();
 941     ok(hwnd != NULL, "create window failed!\n");
 942     hr = AtlAxCreateControlEx(emptyW, hwnd, NULL, &container, &control, &IID_NULL, NULL);
 943     ok(hr == S_OK, "got 0x%08x\n", hr);
 944     todo_wine ok(container != NULL, "returned %p!\n", container);
 945     ok(!control, "returned %p\n", control);
 946     DestroyWindow(hwnd);
 947
 948     container = (IUnknown *)0xdeadbeef;
 949     control = (IUnknown *)0xdeadbeef;
 950     hwnd = create_container_window();
 951     ok(hwnd != NULL, "create window failed!\n");
 952     hr = AtlAxCreateControlEx(randomW, hwnd, NULL, &container, &control, &IID_NULL, NULL);
 953     ok(hr == CO_E_CLASSSTRING, "got 0x%08x\n", hr);
 954     ok(!container, "returned %p!\n", container);
 955     ok(!control, "returned %p\n", control);
 956     DestroyWindow(hwnd);
 957
 958     container = NULL;
 959     control = NULL;
 960     hwnd = create_container_window();
 961     ok(hwnd != NULL, "create window failed!\n");
 962     hr = AtlAxCreateControlEx(progid1W, hwnd, NULL, &container, &control, &IID_NULL, NULL);
 963     ok(hr == S_OK, "got 0x%08x\n", hr);
 964     ok(container != NULL, "returned %p!\n", container);
 965     ok(control != NULL, "returned %p\n", control);
 966     DestroyWindow(hwnd);
 967
 968     container = NULL;
 969     control = NULL;
 970     hwnd = create_container_window();
 971     ok(hwnd != NULL, "create window failed!\n");
 972     hr = AtlAxCreateControlEx(clsid1W, hwnd, NULL, &container, &control, &IID_NULL, NULL);
 973     ok(hr == S_OK, "got 0x%08x\n", hr);
 974     ok(container != NULL, "returned %p!\n", container);
 975     ok(control != NULL, "returned %p\n", control);
 976     IUnknown_Release(container);
 977     IUnknown_Release(control);
 978     DestroyWindow(hwnd);
 979
 980     container = NULL;
 981     control = NULL;
 982     hwnd = create_container_window();
 983     ok(hwnd != NULL, "create window failed!\n");
 984     hr = AtlAxCreateControlEx(url1W, hwnd, NULL, &container, &control, &IID_NULL, NULL);
 985     ok(hr == S_OK, "got 0x%08x\n", hr);
 986     ok(container != NULL, "returned %p!\n", container);
 987     ok(control != NULL, "returned %p\n", control);
 988     IUnknown_Release(container);
 989     IUnknown_Release(control);
 990     DestroyWindow(hwnd);
 991
 992     container = NULL;
 993     control = NULL;
 994     hwnd = create_container_window();
 995     ok(hwnd != NULL, "create window failed!\n");
 996     hr = AtlAxCreateControlEx(mshtml1W, hwnd, NULL, &container, &control, &IID_NULL, NULL);
 997     ok(hr == S_OK, "got 0x%08x\n", hr);
 998     ok(container != NULL, "returned %p!\n", container);
 999     ok(control != NULL, "returned %p\n", control);
1000     IUnknown_Release(container);
1001     IUnknown_Release(control);
1002     DestroyWindow(hwnd);
1003
1004     container = NULL;
1005     control = NULL;
1006     hwnd = create_container_window();
1007     ok(hwnd != NULL, "create window failed!\n");
1008     hr = AtlAxCreateControlEx(mshtml2W, hwnd, NULL, &container, &control, &IID_NULL, NULL);
1009     ok(hr == S_OK, "got 0x%08x\n", hr);
1010     ok(container != NULL, "returned %p!\n", container);
1011     ok(control != NULL, "returned %p\n", control);
1012     IUnknown_Release(container);
1013     IUnknown_Release(control);
1014     DestroyWindow(hwnd);
1015
1016     container = (IUnknown *)0xdeadbeef;
1017     control = (IUnknown *)0xdeadbeef;
1018     hwnd = create_container_window();
1019     ok(hwnd != NULL, "create window failed!\n");
1020     hr = AtlAxCreateControlEx(mshtml3W, hwnd, NULL, &container, &control, &IID_NULL, NULL);
1021     ok(hr == CO_E_CLASSSTRING, "got 0x%08x\n", hr);
1022     ok(!container, "returned %p!\n", container);
1023     ok(!control, "returned %p\n", control);
1024     DestroyWindow(hwnd);
1025
1026     ret = GetTempPathW(MAX_PATH, pathW);
1027     ok(ret, "GetTempPath failed!\n");
1028     lstrcatW(pathW, html_fileW);
1029     hfile = CreateFileW(pathW, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, 0);
1030     ok(hfile != INVALID_HANDLE_VALUE, "failed to create file\n");
1031     ret = WriteFile(hfile, html_str, sizeof(html_str), &ret_size, NULL);
1032     ok(ret, "WriteFile failed\n");
1033     CloseHandle(hfile);
1034
1035     /* test C:// scheme */
1036     container = NULL;
1037     control = NULL;
1038     hwnd = create_container_window();
1039     ok(hwnd != NULL, "create window failed!\n");
1040     hr = AtlAxCreateControlEx(pathW, hwnd, NULL, &container, &control, &IID_NULL, NULL);
1041     ok(hr == S_OK, "got 0x%08x\n", hr);
1042     ok(container != NULL, "returned %p!\n", container);
1043     ok(control != NULL, "returned %p\n", control);
1044     IUnknown_Release(container);
1045     IUnknown_Release(control);
1046     DestroyWindow(hwnd);
1047
1048     /* test file:// scheme */
1049     lstrcpyW(file_uri1W, fileW);
1050     lstrcatW(file_uri1W, pathW);
1051     container = NULL;
1052     control = NULL;
1053     hwnd = create_container_window();
1054     ok(hwnd != NULL, "create window failed!\n");
1055     hr = AtlAxCreateControlEx(file_uri1W, hwnd, NULL, &container, &control, &IID_NULL, NULL);
1056     ok(hr == S_OK, "got 0x%08x\n", hr);
1057     ok(container != NULL, "returned %p!\n", container);
1058     ok(control != NULL, "returned %p\n", control);
1059     IUnknown_Release(container);
1060     IUnknown_Release(control);
1061     DestroyWindow(hwnd);
1062
1063     /* test file:// scheme on non-existent file. */
1064     ret = DeleteFileW(pathW);
1065     ok(ret, "DeleteFile failed!\n");
1066     container = NULL;
1067     control = NULL;
1068     hwnd = create_container_window();
1069     ok(hwnd != NULL, "create window failed!\n");
1070     hr = AtlAxCreateControlEx(file_uri1W, hwnd, NULL, &container, &control, &IID_NULL, NULL);
1071     ok(hr == S_OK, "got 0x%08x\n", hr);
1072     ok(container != NULL, "returned %p!\n", container);
1073     ok(control != NULL, "returned %p\n", control);
1074     IUnknown_Release(container);
1075     IUnknown_Release(control);
1076     DestroyWindow(hwnd);
1077 }
1078
1079 START_TEST(atl)
1080 {
1081     if (!register_class())
1082         return;
1083
1084     CoInitialize(NULL);
1085
1086     test_winmodule();
1087     test_regcat();
1088     test_typelib();
1089     test_cp();
1090     test_source_iface();
1091     test_ax_win();
1092     test_AtlAxAttachControl();
1093     test_AtlAxCreateControl();
1094
1095     CoUninitialize();
1096 }