dlls/ole32/tests/compobj.c

   1 /*
   2  * Component Object Tests
   3  *
   4  * Copyright 2005 Robert Shearman
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22 #define CONST_VTABLE
  23
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #define USE_COM_CONTEXT_DEF
  30 #include "initguid.h"
  31 #include "objbase.h"
  32 #include "shlguid.h"
  33 #include "urlmon.h" /* for CLSID_FileProtocol */
  34
  35 #include "ctxtcall.h"
  36
  37 #include "wine/test.h"
  38
  39 /* functions that are not present on all versions of Windows */
  40 static HRESULT (WINAPI * pCoInitializeEx)(LPVOID lpReserved, DWORD dwCoInit);
  41 static HRESULT (WINAPI * pCoGetObjectContext)(REFIID riid, LPVOID *ppv);
  42 static HRESULT (WINAPI * pCoSwitchCallContext)(IUnknown *pObject, IUnknown **ppOldObject);
  43 static HRESULT (WINAPI * pCoGetTreatAsClass)(REFCLSID clsidOld, LPCLSID pClsidNew);
  44 static HRESULT (WINAPI * pCoGetContextToken)(ULONG_PTR *token);
  45 static LONG (WINAPI * pRegOverridePredefKey)(HKEY key, HKEY override);
  46
  47 static BOOL   (WINAPI *pActivateActCtx)(HANDLE,ULONG_PTR*);
  48 static HANDLE (WINAPI *pCreateActCtxW)(PCACTCTXW);
  49 static BOOL   (WINAPI *pDeactivateActCtx)(DWORD,ULONG_PTR);
  50 static void   (WINAPI *pReleaseActCtx)(HANDLE);
  51
  52 #define ok_ole_success(hr, func) ok(hr == S_OK, func " failed with error 0x%08x\n", hr)
  53 #define ok_more_than_one_lock() ok(cLocks > 0, "Number of locks should be > 0, but actually is %d\n", cLocks)
  54 #define ok_no_locks() ok(cLocks == 0, "Number of locks should be 0, but actually is %d\n", cLocks)
  55
  56 static const CLSID CLSID_non_existent =   { 0x12345678, 0x1234, 0x1234, { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 } };
  57 static const CLSID CLSID_StdFont = { 0x0be35203, 0x8f91, 0x11ce, { 0x9d, 0xe3, 0x00, 0xaa, 0x00, 0x4b, 0xb8, 0x51 } };
  58 static WCHAR stdfont[] = {'S','t','d','F','o','n','t',0};
  59 static const WCHAR wszNonExistent[] = {'N','o','n','E','x','i','s','t','e','n','t',0};
  60 static WCHAR wszCLSID_StdFont[] =
  61 {
  62     '{','0','b','e','3','5','2','0','3','-','8','f','9','1','-','1','1','c','e','-',
  63     '9','d','e','3','-','0','0','a','a','0','0','4','b','b','8','5','1','}',0
  64 };
  65 static const WCHAR progidW[] = {'P','r','o','g','I','d','.','P','r','o','g','I','d',0};
  66
  67 DEFINE_GUID(IID_IWineTest, 0x5201163f, 0x8164, 0x4fd0, 0xa1, 0xa2, 0x5d, 0x5a, 0x36, 0x54, 0xd3, 0xbd);
  68 DEFINE_GUID(CLSID_WineOOPTest, 0x5201163f, 0x8164, 0x4fd0, 0xa1, 0xa2, 0x5d, 0x5a, 0x36, 0x54, 0xd3, 0xbd);
  69
  70 static const char *debugstr_guid(REFIID riid)
  71 {
  72     static char buf[50];
  73
  74     sprintf(buf, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
  75             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
  76             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
  77             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
  78
  79     return buf;
  80 }
  81
  82 static LONG cLocks;
  83
  84 static void LockModule(void)
  85 {
  86     InterlockedIncrement(&cLocks);
  87 }
  88
  89 static void UnlockModule(void)
  90 {
  91     InterlockedDecrement(&cLocks);
  92 }
  93
  94 static HRESULT WINAPI Test_IClassFactory_QueryInterface(
  95     LPCLASSFACTORY iface,
  96     REFIID riid,
  97     LPVOID *ppvObj)
  98 {
  99     if (ppvObj == NULL) return E_POINTER;
 100
 101     if (IsEqualGUID(riid, &IID_IUnknown) ||
 102         IsEqualGUID(riid, &IID_IClassFactory))
 103     {
 104         *ppvObj = iface;
 105         IClassFactory_AddRef(iface);
 106         return S_OK;
 107     }
 108
 109     *ppvObj = NULL;
 110     return E_NOINTERFACE;
 111 }
 112
 113 static ULONG WINAPI Test_IClassFactory_AddRef(LPCLASSFACTORY iface)
 114 {
 115     LockModule();
 116     return 2; /* non-heap-based object */
 117 }
 118
 119 static ULONG WINAPI Test_IClassFactory_Release(LPCLASSFACTORY iface)
 120 {
 121     UnlockModule();
 122     return 1; /* non-heap-based object */
 123 }
 124
 125 static HRESULT WINAPI Test_IClassFactory_CreateInstance(
 126     LPCLASSFACTORY iface,
 127     IUnknown *pUnkOuter,
 128     REFIID riid,
 129     LPVOID *ppvObj)
 130 {
 131     *ppvObj = NULL;
 132     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
 133     return E_NOINTERFACE;
 134 }
 135
 136 static HRESULT WINAPI Test_IClassFactory_LockServer(
 137     LPCLASSFACTORY iface,
 138     BOOL fLock)
 139 {
 140     return S_OK;
 141 }
 142
 143 static const IClassFactoryVtbl TestClassFactory_Vtbl =
 144 {
 145     Test_IClassFactory_QueryInterface,
 146     Test_IClassFactory_AddRef,
 147     Test_IClassFactory_Release,
 148     Test_IClassFactory_CreateInstance,
 149     Test_IClassFactory_LockServer
 150 };
 151
 152 static IClassFactory Test_ClassFactory = { &TestClassFactory_Vtbl };
 153
 154 static WCHAR manifest_path[MAX_PATH];
 155
 156 static BOOL create_manifest_file(const char *filename, const char *manifest)
 157 {
 158     int manifest_len;
 159     DWORD size;
 160     HANDLE file;
 161     WCHAR path[MAX_PATH];
 162
 163     MultiByteToWideChar( CP_ACP, 0, filename, -1, path, MAX_PATH );
 164     GetFullPathNameW(path, sizeof(manifest_path)/sizeof(WCHAR), manifest_path, NULL);
 165
 166     manifest_len = strlen(manifest);
 167     file = CreateFileW(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 168                        FILE_ATTRIBUTE_NORMAL, NULL);
 169     ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %u\n", GetLastError());
 170     if(file == INVALID_HANDLE_VALUE)
 171         return FALSE;
 172     WriteFile(file, manifest, manifest_len, &size, NULL);
 173     CloseHandle(file);
 174
 175     return TRUE;
 176 }
 177
 178 static HANDLE activate_context(const char *manifest, ULONG_PTR *cookie)
 179 {
 180     WCHAR path[MAX_PATH];
 181     ACTCTXW actctx;
 182     HANDLE handle;
 183     BOOL ret;
 184
 185     if (!pCreateActCtxW) return NULL;
 186
 187     create_manifest_file("file.manifest", manifest);
 188
 189     MultiByteToWideChar( CP_ACP, 0, "file.manifest", -1, path, MAX_PATH );
 190     memset(&actctx, 0, sizeof(ACTCTXW));
 191     actctx.cbSize = sizeof(ACTCTXW);
 192     actctx.lpSource = path;
 193
 194     handle = pCreateActCtxW(&actctx);
 195     ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
 196
 197     ok(actctx.cbSize == sizeof(ACTCTXW), "actctx.cbSize=%d\n", actctx.cbSize);
 198     ok(actctx.dwFlags == 0, "actctx.dwFlags=%d\n", actctx.dwFlags);
 199     ok(actctx.lpSource == path, "actctx.lpSource=%p\n", actctx.lpSource);
 200     ok(actctx.wProcessorArchitecture == 0, "actctx.wProcessorArchitecture=%d\n", actctx.wProcessorArchitecture);
 201     ok(actctx.wLangId == 0, "actctx.wLangId=%d\n", actctx.wLangId);
 202     ok(actctx.lpAssemblyDirectory == NULL, "actctx.lpAssemblyDirectory=%p\n", actctx.lpAssemblyDirectory);
 203     ok(actctx.lpResourceName == NULL, "actctx.lpResourceName=%p\n", actctx.lpResourceName);
 204     ok(actctx.lpApplicationName == NULL, "actctx.lpApplicationName=%p\n", actctx.lpApplicationName);
 205     ok(actctx.hModule == NULL, "actctx.hModule=%p\n", actctx.hModule);
 206
 207     DeleteFileA("file.manifest");
 208
 209     ret = pActivateActCtx(handle, cookie);
 210     ok(ret, "ActivateActCtx failed: %u\n", GetLastError());
 211
 212     return handle;
 213 }
 214
 215 static const char actctx_manifest[] =
 216 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
 217 "<assemblyIdentity version=\"1.2.3.4\"  name=\"Wine.Test\" type=\"win32\""
 218 " publicKeyToken=\"6595b6414666f1df\" />"
 219 "<file name=\"testlib.dll\">"
 220 "    <comClass description=\"Test com class\""
 221 "              clsid=\"{12345678-1234-1234-1234-56789abcdef0}\""
 222 "              progid=\"ProgId.ProgId\""
 223 "              miscStatusIcon=\"recomposeonresize\""
 224 "    />"
 225 "    <comClass clsid=\"{0be35203-8f91-11ce-9de3-00aa004bb851}\""
 226 "              progid=\"CustomFont\""
 227 "              miscStatusIcon=\"recomposeonresize\""
 228 "              miscStatusContent=\"insideout\""
 229 "    />"
 230 "    <comClass clsid=\"{0be35203-8f91-11ce-9de3-00aa004bb852}\""
 231 "              progid=\"StdFont\""
 232 "    />"
 233 "</file>"
 234 "</assembly>";
 235
 236 DEFINE_GUID(CLSID_Testclass, 0x12345678, 0x1234, 0x1234, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0);
 237
 238 static void test_ProgIDFromCLSID(void)
 239 {
 240     ULONG_PTR cookie = 0;
 241     LPWSTR progid;
 242     HANDLE handle;
 243     HRESULT hr;
 244
 245     hr = ProgIDFromCLSID(&CLSID_StdFont, &progid);
 246     ok(hr == S_OK, "ProgIDFromCLSID failed with error 0x%08x\n", hr);
 247     if (hr == S_OK)
 248     {
 249         ok(!lstrcmpiW(progid, stdfont), "Didn't get expected prog ID\n");
 250         CoTaskMemFree(progid);
 251     }
 252
 253     progid = (LPWSTR)0xdeadbeef;
 254     hr = ProgIDFromCLSID(&CLSID_non_existent, &progid);
 255     ok(hr == REGDB_E_CLASSNOTREG, "ProgIDFromCLSID returned %08x\n", hr);
 256     ok(progid == NULL, "ProgIDFromCLSID returns with progid %p\n", progid);
 257
 258     hr = ProgIDFromCLSID(&CLSID_StdFont, NULL);
 259     ok(hr == E_INVALIDARG, "ProgIDFromCLSID should return E_INVALIDARG instead of 0x%08x\n", hr);
 260
 261     if ((handle = activate_context(actctx_manifest, &cookie)))
 262     {
 263         static const WCHAR customfontW[] = {'C','u','s','t','o','m','F','o','n','t',0};
 264
 265         hr = ProgIDFromCLSID(&CLSID_non_existent, &progid);
 266 todo_wine
 267         ok(hr == S_OK, "got 0x%08x\n", hr);
 268         if (hr == S_OK)
 269         {
 270             ok(!lstrcmpiW(progid, progidW), "got %s\n", wine_dbgstr_w(progid));
 271             CoTaskMemFree(progid);
 272         }
 273
 274         /* try something registered and redirected */
 275         progid = NULL;
 276         hr = ProgIDFromCLSID(&CLSID_StdFont, &progid);
 277         ok(hr == S_OK, "got 0x%08x\n", hr);
 278 todo_wine
 279         ok(!lstrcmpiW(progid, customfontW), "got wrong progid %s\n", wine_dbgstr_w(progid));
 280         CoTaskMemFree(progid);
 281
 282         pDeactivateActCtx(0, cookie);
 283         pReleaseActCtx(handle);
 284     }
 285 }
 286
 287 static void test_CLSIDFromProgID(void)
 288 {
 289     ULONG_PTR cookie = 0;
 290     HANDLE handle;
 291     CLSID clsid;
 292     HRESULT hr = CLSIDFromProgID(stdfont, &clsid);
 293     ok(hr == S_OK, "CLSIDFromProgID failed with error 0x%08x\n", hr);
 294     ok(IsEqualCLSID(&clsid, &CLSID_StdFont), "clsid wasn't equal to CLSID_StdFont\n");
 295
 296     hr = CLSIDFromString(stdfont, &clsid);
 297     ok_ole_success(hr, "CLSIDFromString");
 298     ok(IsEqualCLSID(&clsid, &CLSID_StdFont), "clsid wasn't equal to CLSID_StdFont\n");
 299
 300     /* test some failure cases */
 301
 302     hr = CLSIDFromProgID(wszNonExistent, NULL);
 303     ok(hr == E_INVALIDARG, "CLSIDFromProgID should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 304
 305     hr = CLSIDFromProgID(NULL, &clsid);
 306     ok(hr == E_INVALIDARG, "CLSIDFromProgID should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 307
 308     memset(&clsid, 0xcc, sizeof(clsid));
 309     hr = CLSIDFromProgID(wszNonExistent, &clsid);
 310     ok(hr == CO_E_CLASSSTRING, "CLSIDFromProgID on nonexistent ProgID should have returned CO_E_CLASSSTRING instead of 0x%08x\n", hr);
 311     ok(IsEqualCLSID(&clsid, &CLSID_NULL), "CLSIDFromProgID should have set clsid to all-zeros on failure\n");
 312
 313     /* fails without proper context */
 314     memset(&clsid, 0xcc, sizeof(clsid));
 315     hr = CLSIDFromProgID(progidW, &clsid);
 316     ok(hr == CO_E_CLASSSTRING, "got 0x%08x\n", hr);
 317     ok(IsEqualCLSID(&clsid, &CLSID_NULL), "wrong clsid\n");
 318
 319     if ((handle = activate_context(actctx_manifest, &cookie)))
 320     {
 321         GUID clsid1;
 322
 323         clsid = CLSID_NULL;
 324         hr = CLSIDFromProgID(progidW, &clsid);
 325 todo_wine
 326         ok(hr == S_OK, "got 0x%08x\n", hr);
 327         if (hr == S_OK)
 328             /* it returns generated CLSID here */
 329             ok(!IsEqualCLSID(&clsid, &CLSID_non_existent) && !IsEqualCLSID(&clsid, &CLSID_NULL),
 330                 "got wrong clsid %s\n", debugstr_guid(&clsid));
 331
 332         /* duplicate progid present in context - returns generated guid here too */
 333         clsid = CLSID_NULL;
 334         hr = CLSIDFromProgID(stdfont, &clsid);
 335         ok(hr == S_OK, "got 0x%08x\n", hr);
 336         clsid1 = CLSID_StdFont;
 337         /* that's where it differs from StdFont */
 338         clsid1.Data4[7] = 0x52;
 339 todo_wine
 340         ok(!IsEqualCLSID(&clsid, &CLSID_StdFont) && !IsEqualCLSID(&clsid, &CLSID_NULL) && !IsEqualCLSID(&clsid, &clsid1),
 341             "got %s\n", debugstr_guid(&clsid));
 342
 343         pDeactivateActCtx(0, cookie);
 344         pReleaseActCtx(handle);
 345     }
 346 }
 347
 348 static void test_CLSIDFromString(void)
 349 {
 350     CLSID clsid;
 351     WCHAR wszCLSID_Broken[50];
 352     UINT i;
 353
 354     HRESULT hr = CLSIDFromString(wszCLSID_StdFont, &clsid);
 355     ok_ole_success(hr, "CLSIDFromString");
 356     ok(IsEqualCLSID(&clsid, &CLSID_StdFont), "clsid wasn't equal to CLSID_StdFont\n");
 357
 358     hr = CLSIDFromString(NULL, &clsid);
 359     ok_ole_success(hr, "CLSIDFromString");
 360     ok(IsEqualCLSID(&clsid, &CLSID_NULL), "clsid wasn't equal to CLSID_NULL\n");
 361
 362     lstrcpyW(wszCLSID_Broken, wszCLSID_StdFont);
 363     for(i = lstrlenW(wszCLSID_StdFont); i < 49; i++)
 364         wszCLSID_Broken[i] = 'A';
 365     wszCLSID_Broken[i] = '\0';
 366
 367     memset(&clsid, 0, sizeof(CLSID));
 368     hr = CLSIDFromString(wszCLSID_Broken, &clsid);
 369     ok(hr == CO_E_CLASSSTRING, "Got %08x\n", hr);
 370     ok(IsEqualCLSID(&clsid, &CLSID_StdFont), "clsid wasn't equal to CLSID_StdFont\n");
 371
 372     wszCLSID_Broken[lstrlenW(wszCLSID_StdFont)-1] = 'A';
 373     memset(&clsid, 0, sizeof(CLSID));
 374     hr = CLSIDFromString(wszCLSID_Broken, &clsid);
 375     ok(hr == CO_E_CLASSSTRING, "Got %08x\n", hr);
 376     ok(IsEqualCLSID(&clsid, &CLSID_StdFont), "clsid wasn't equal to CLSID_StdFont\n");
 377
 378     wszCLSID_Broken[lstrlenW(wszCLSID_StdFont)] = '\0';
 379     memset(&clsid, 0, sizeof(CLSID));
 380     hr = CLSIDFromString(wszCLSID_Broken, &clsid);
 381     ok(hr == CO_E_CLASSSTRING, "Got %08x\n", hr);
 382     ok(IsEqualCLSID(&clsid, &CLSID_StdFont), "clsid wasn't equal to CLSID_StdFont\n");
 383
 384     wszCLSID_Broken[lstrlenW(wszCLSID_StdFont)-1] = '\0';
 385     memset(&clsid, 0, sizeof(CLSID));
 386     hr = CLSIDFromString(wszCLSID_Broken, &clsid);
 387     ok(hr == CO_E_CLASSSTRING, "Got %08x\n", hr);
 388     ok(IsEqualCLSID(&clsid, &CLSID_StdFont), "clsid wasn't equal to CLSID_StdFont\n");
 389
 390     memset(&clsid, 0xcc, sizeof(CLSID));
 391     hr = CLSIDFromString(wszCLSID_Broken+1, &clsid);
 392     ok(hr == CO_E_CLASSSTRING, "Got %08x\n", hr);
 393     ok(IsEqualCLSID(&clsid, &CLSID_NULL), "clsid wasn't equal to CLSID_NULL\n");
 394
 395     wszCLSID_Broken[9] = '*';
 396     memset(&clsid, 0xcc, sizeof(CLSID));
 397     hr = CLSIDFromString(wszCLSID_Broken, &clsid);
 398     ok(hr == CO_E_CLASSSTRING, "Got %08x\n", hr);
 399     ok(clsid.Data1 == CLSID_StdFont.Data1, "Got %08x\n", clsid.Data1);
 400     ok(clsid.Data2 == 0xcccc, "Got %04x\n", clsid.Data2);
 401
 402     wszCLSID_Broken[3] = '*';
 403     memset(&clsid, 0xcc, sizeof(CLSID));
 404     hr = CLSIDFromString(wszCLSID_Broken, &clsid);
 405     ok(hr == CO_E_CLASSSTRING, "Got %08x\n", hr);
 406     ok(clsid.Data1 == 0xb, "Got %08x\n", clsid.Data1);
 407     ok(clsid.Data2 == 0xcccc, "Got %04x\n", clsid.Data2);
 408
 409     wszCLSID_Broken[3] = '\0';
 410     memset(&clsid, 0xcc, sizeof(CLSID));
 411     hr = CLSIDFromString(wszCLSID_Broken, &clsid);
 412     ok(hr == CO_E_CLASSSTRING, "Got %08x\n", hr);
 413     ok(clsid.Data1 == 0xb, "Got %08x\n", clsid.Data1);
 414     ok(clsid.Data2 == 0xcccc, "Got %04x\n", clsid.Data2);
 415 }
 416
 417 static void test_StringFromGUID2(void)
 418 {
 419   WCHAR str[50];
 420   int len;
 421
 422   /* invalid pointer */
 423   SetLastError(0xdeadbeef);
 424   len = StringFromGUID2(NULL,str,50);
 425   ok(len == 0, "len: %d (expected 0)\n", len);
 426   ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %x\n", GetLastError());
 427
 428   /* Test corner cases for buffer size */
 429   len = StringFromGUID2(&CLSID_StdFont,str,50);
 430   ok(len == 39, "len: %d (expected 39)\n", len);
 431   ok(!lstrcmpiW(str, wszCLSID_StdFont),"string wasn't equal for CLSID_StdFont\n");
 432
 433   memset(str,0,sizeof str);
 434   len = StringFromGUID2(&CLSID_StdFont,str,39);
 435   ok(len == 39, "len: %d (expected 39)\n", len);
 436   ok(!lstrcmpiW(str, wszCLSID_StdFont),"string wasn't equal for CLSID_StdFont\n");
 437
 438   len = StringFromGUID2(&CLSID_StdFont,str,38);
 439   ok(len == 0, "len: %d (expected 0)\n", len);
 440
 441   len = StringFromGUID2(&CLSID_StdFont,str,30);
 442   ok(len == 0, "len: %d (expected 0)\n", len);
 443 }
 444
 445 struct info
 446 {
 447     HANDLE wait, stop;
 448 };
 449
 450 static DWORD CALLBACK ole_initialize_thread(LPVOID pv)
 451 {
 452     HRESULT hr;
 453     struct info *info = pv;
 454
 455     hr = pCoInitializeEx(NULL, COINIT_MULTITHREADED);
 456
 457     SetEvent(info->wait);
 458     WaitForSingleObject(info->stop, 10000);
 459
 460     CoUninitialize();
 461     return hr;
 462 }
 463
 464 static void test_CoCreateInstance(void)
 465 {
 466     HRESULT hr;
 467     HANDLE thread;
 468     DWORD tid, exitcode;
 469     IUnknown *pUnk;
 470     struct info info;
 471     REFCLSID rclsid = &CLSID_InternetZoneManager;
 472
 473     pUnk = (IUnknown *)0xdeadbeef;
 474     hr = CoCreateInstance(rclsid, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)&pUnk);
 475     ok(hr == CO_E_NOTINITIALIZED, "CoCreateInstance should have returned CO_E_NOTINITIALIZED instead of 0x%08x\n", hr);
 476     ok(pUnk == NULL, "CoCreateInstance should have changed the passed in pointer to NULL, instead of %p\n", pUnk);
 477
 478     OleInitialize(NULL);
 479
 480     /* test errors returned for non-registered clsids */
 481     hr = CoCreateInstance(&CLSID_non_existent, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)&pUnk);
 482     ok(hr == REGDB_E_CLASSNOTREG, "CoCreateInstance for non-registered inproc server should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
 483     hr = CoCreateInstance(&CLSID_non_existent, NULL, CLSCTX_INPROC_HANDLER, &IID_IUnknown, (void **)&pUnk);
 484     ok(hr == REGDB_E_CLASSNOTREG, "CoCreateInstance for non-registered inproc handler should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
 485     hr = CoCreateInstance(&CLSID_non_existent, NULL, CLSCTX_LOCAL_SERVER, &IID_IUnknown, (void **)&pUnk);
 486     ok(hr == REGDB_E_CLASSNOTREG, "CoCreateInstance for non-registered local server should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
 487     hr = CoCreateInstance(&CLSID_non_existent, NULL, CLSCTX_REMOTE_SERVER, &IID_IUnknown, (void **)&pUnk);
 488     ok(hr == REGDB_E_CLASSNOTREG, "CoCreateInstance for non-registered remote server should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
 489
 490     hr = CoCreateInstance(rclsid, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)&pUnk);
 491     if(hr == REGDB_E_CLASSNOTREG)
 492     {
 493         skip("IE not installed so can't test CoCreateInstance\n");
 494         OleUninitialize();
 495         return;
 496     }
 497
 498     ok_ole_success(hr, "CoCreateInstance");
 499     if(pUnk) IUnknown_Release(pUnk);
 500     OleUninitialize();
 501
 502     hr = CoCreateInstance(rclsid, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)&pUnk);
 503     ok(hr == CO_E_NOTINITIALIZED, "CoCreateInstance should have returned CO_E_NOTINITIALIZED instead of 0x%08x\n", hr);
 504
 505     /* show that COM doesn't have to be initialized for multi-threaded apartments if another
 506        thread has already done so */
 507
 508     info.wait = CreateEvent(NULL, TRUE, FALSE, NULL);
 509     ok(info.wait != NULL, "CreateEvent failed with error %d\n", GetLastError());
 510
 511     info.stop = CreateEvent(NULL, TRUE, FALSE, NULL);
 512     ok(info.stop != NULL, "CreateEvent failed with error %d\n", GetLastError());
 513
 514     thread = CreateThread(NULL, 0, ole_initialize_thread, &info, 0, &tid);
 515     ok(thread != NULL, "CreateThread failed with error %d\n", GetLastError());
 516
 517     ok( !WaitForSingleObject(info.wait, 10000 ), "wait timed out\n" );
 518
 519     pUnk = (IUnknown *)0xdeadbeef;
 520     hr = CoCreateInstance(rclsid, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)&pUnk);
 521     ok(hr == S_OK, "CoCreateInstance should have returned S_OK instead of 0x%08x\n", hr);
 522     if (pUnk) IUnknown_Release(pUnk);
 523
 524     SetEvent(info.stop);
 525     ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
 526
 527     GetExitCodeThread(thread, &exitcode);
 528     hr = exitcode;
 529     ok(hr == S_OK, "thread should have returned S_OK instead of 0x%08x\n", hr);
 530
 531     CloseHandle(thread);
 532     CloseHandle(info.wait);
 533     CloseHandle(info.stop);
 534 }
 535
 536 static void test_CoGetClassObject(void)
 537 {
 538     HRESULT hr;
 539     HANDLE thread;
 540     DWORD tid, exitcode;
 541     IUnknown *pUnk;
 542     struct info info;
 543     REFCLSID rclsid = &CLSID_InternetZoneManager;
 544     HKEY hkey;
 545     LONG res;
 546
 547     hr = CoGetClassObject(rclsid, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void **)&pUnk);
 548     ok(hr == CO_E_NOTINITIALIZED, "CoGetClassObject should have returned CO_E_NOTINITIALIZED instead of 0x%08x\n", hr);
 549     ok(pUnk == NULL, "CoGetClassObject should have changed the passed in pointer to NULL, instead of %p\n", pUnk);
 550
 551     hr = CoGetClassObject(rclsid, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, NULL);
 552     ok(hr == E_INVALIDARG ||
 553        broken(hr == CO_E_NOTINITIALIZED), /* win9x */
 554        "CoGetClassObject should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 555
 556     /* show that COM doesn't have to be initialized for multi-threaded apartments if another
 557        thread has already done so */
 558
 559     info.wait = CreateEvent(NULL, TRUE, FALSE, NULL);
 560     ok(info.wait != NULL, "CreateEvent failed with error %d\n", GetLastError());
 561
 562     info.stop = CreateEvent(NULL, TRUE, FALSE, NULL);
 563     ok(info.stop != NULL, "CreateEvent failed with error %d\n", GetLastError());
 564
 565     thread = CreateThread(NULL, 0, ole_initialize_thread, &info, 0, &tid);
 566     ok(thread != NULL, "CreateThread failed with error %d\n", GetLastError());
 567
 568     ok( !WaitForSingleObject(info.wait, 10000), "wait timed out\n" );
 569
 570     pUnk = (IUnknown *)0xdeadbeef;
 571     hr = CoGetClassObject(rclsid, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void **)&pUnk);
 572     if(hr == REGDB_E_CLASSNOTREG)
 573         skip("IE not installed so can't test CoGetClassObject\n");
 574     else
 575     {
 576         ok(hr == S_OK, "CoGetClassObject should have returned S_OK instead of 0x%08x\n", hr);
 577         if (pUnk) IUnknown_Release(pUnk);
 578     }
 579
 580     SetEvent(info.stop);
 581     ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
 582
 583     GetExitCodeThread(thread, &exitcode);
 584     hr = exitcode;
 585     ok(hr == S_OK, "thread should have returned S_OK instead of 0x%08x\n", hr);
 586
 587     CloseHandle(thread);
 588     CloseHandle(info.wait);
 589     CloseHandle(info.stop);
 590
 591     if (!pRegOverridePredefKey)
 592     {
 593         win_skip("RegOverridePredefKey not available\n");
 594         return;
 595     }
 596
 597     pCoInitializeEx(NULL, COINIT_MULTITHREADED);
 598
 599     hr = CoGetClassObject(rclsid, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void **)&pUnk);
 600     if (hr == S_OK)
 601     {
 602         IUnknown_Release(pUnk);
 603
 604         res = RegCreateKeyEx(HKEY_CURRENT_USER, "Software\\Classes", 0, NULL, 0,
 605                              KEY_ALL_ACCESS, NULL, &hkey, NULL);
 606         ok(!res, "RegCreateKeyEx returned %d\n", res);
 607
 608         res = pRegOverridePredefKey(HKEY_CLASSES_ROOT, hkey);
 609         ok(!res, "RegOverridePredefKey returned %d\n", res);
 610
 611         hr = CoGetClassObject(rclsid, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void **)&pUnk);
 612         ok(hr == S_OK, "CoGetClassObject should have returned S_OK instead of 0x%08x\n", hr);
 613
 614         res = pRegOverridePredefKey(HKEY_CLASSES_ROOT, NULL);
 615         ok(!res, "RegOverridePredefKey returned %d\n", res);
 616
 617         if (hr == S_OK) IUnknown_Release(pUnk);
 618         RegCloseKey(hkey);
 619     }
 620     CoUninitialize();
 621 }
 622
 623 static ATOM register_dummy_class(void)
 624 {
 625     WNDCLASS wc =
 626     {
 627         0,
 628         DefWindowProc,
 629         0,
 630         0,
 631         GetModuleHandle(NULL),
 632         NULL,
 633         LoadCursor(NULL, IDC_ARROW),
 634         (HBRUSH)(COLOR_BTNFACE+1),
 635         NULL,
 636         TEXT("WineOleTestClass"),
 637     };
 638
 639     return RegisterClass(&wc);
 640 }
 641
 642 static void test_ole_menu(void)
 643 {
 644         HWND hwndFrame;
 645         HRESULT hr;
 646
 647         hwndFrame = CreateWindow(MAKEINTATOM(register_dummy_class()), "Test", 0, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, NULL, NULL);
 648         hr = OleSetMenuDescriptor(NULL, hwndFrame, NULL, NULL, NULL);
 649         todo_wine ok_ole_success(hr, "OleSetMenuDescriptor");
 650
 651         DestroyWindow(hwndFrame);
 652 }
 653
 654
 655 static HRESULT WINAPI MessageFilter_QueryInterface(IMessageFilter *iface, REFIID riid, void ** ppvObj)
 656 {
 657     if (ppvObj == NULL) return E_POINTER;
 658
 659     if (IsEqualGUID(riid, &IID_IUnknown) ||
 660         IsEqualGUID(riid, &IID_IClassFactory))
 661     {
 662         *ppvObj = iface;
 663         IMessageFilter_AddRef(iface);
 664         return S_OK;
 665     }
 666
 667     return E_NOINTERFACE;
 668 }
 669
 670 static ULONG WINAPI MessageFilter_AddRef(IMessageFilter *iface)
 671 {
 672     return 2; /* non-heap object */
 673 }
 674
 675 static ULONG WINAPI MessageFilter_Release(IMessageFilter *iface)
 676 {
 677     return 1; /* non-heap object */
 678 }
 679
 680 static DWORD WINAPI MessageFilter_HandleInComingCall(
 681   IMessageFilter *iface,
 682   DWORD dwCallType,
 683   HTASK threadIDCaller,
 684   DWORD dwTickCount,
 685   LPINTERFACEINFO lpInterfaceInfo)
 686 {
 687     trace("HandleInComingCall\n");
 688     return SERVERCALL_ISHANDLED;
 689 }
 690
 691 static DWORD WINAPI MessageFilter_RetryRejectedCall(
 692   IMessageFilter *iface,
 693   HTASK threadIDCallee,
 694   DWORD dwTickCount,
 695   DWORD dwRejectType)
 696 {
 697     trace("RetryRejectedCall\n");
 698     return 0;
 699 }
 700
 701 static DWORD WINAPI MessageFilter_MessagePending(
 702   IMessageFilter *iface,
 703   HTASK threadIDCallee,
 704   DWORD dwTickCount,
 705   DWORD dwPendingType)
 706 {
 707     trace("MessagePending\n");
 708     return PENDINGMSG_WAITNOPROCESS;
 709 }
 710
 711 static const IMessageFilterVtbl MessageFilter_Vtbl =
 712 {
 713     MessageFilter_QueryInterface,
 714     MessageFilter_AddRef,
 715     MessageFilter_Release,
 716     MessageFilter_HandleInComingCall,
 717     MessageFilter_RetryRejectedCall,
 718     MessageFilter_MessagePending
 719 };
 720
 721 static IMessageFilter MessageFilter = { &MessageFilter_Vtbl };
 722
 723 static void test_CoRegisterMessageFilter(void)
 724 {
 725     HRESULT hr;
 726     IMessageFilter *prev_filter;
 727
 728     hr = CoRegisterMessageFilter(&MessageFilter, &prev_filter);
 729     ok(hr == CO_E_NOT_SUPPORTED,
 730         "CoRegisterMessageFilter should have failed with CO_E_NOT_SUPPORTED instead of 0x%08x\n",
 731         hr);
 732
 733     pCoInitializeEx(NULL, COINIT_MULTITHREADED);
 734     prev_filter = (IMessageFilter *)0xdeadbeef;
 735     hr = CoRegisterMessageFilter(&MessageFilter, &prev_filter);
 736     ok(hr == CO_E_NOT_SUPPORTED,
 737         "CoRegisterMessageFilter should have failed with CO_E_NOT_SUPPORTED instead of 0x%08x\n",
 738         hr);
 739     ok(prev_filter == (IMessageFilter *)0xdeadbeef,
 740         "prev_filter should have been set to %p\n", prev_filter);
 741     CoUninitialize();
 742
 743     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 744
 745     hr = CoRegisterMessageFilter(NULL, NULL);
 746     ok_ole_success(hr, "CoRegisterMessageFilter");
 747
 748     prev_filter = (IMessageFilter *)0xdeadbeef;
 749     hr = CoRegisterMessageFilter(NULL, &prev_filter);
 750     ok_ole_success(hr, "CoRegisterMessageFilter");
 751     ok(prev_filter == NULL, "prev_filter should have been set to NULL instead of %p\n", prev_filter);
 752
 753     hr = CoRegisterMessageFilter(&MessageFilter, &prev_filter);
 754     ok_ole_success(hr, "CoRegisterMessageFilter");
 755     ok(prev_filter == NULL, "prev_filter should have been set to NULL instead of %p\n", prev_filter);
 756
 757     hr = CoRegisterMessageFilter(NULL, NULL);
 758     ok_ole_success(hr, "CoRegisterMessageFilter");
 759
 760     CoUninitialize();
 761 }
 762
 763 static HRESULT WINAPI Test_IUnknown_QueryInterface(
 764     IUnknown *iface,
 765     REFIID riid,
 766     LPVOID *ppvObj)
 767 {
 768     if (ppvObj == NULL) return E_POINTER;
 769
 770     if (IsEqualIID(riid, &IID_IUnknown) ||
 771         IsEqualIID(riid, &IID_IWineTest))
 772     {
 773         *ppvObj = iface;
 774         IUnknown_AddRef(iface);
 775         return S_OK;
 776     }
 777
 778     *ppvObj = NULL;
 779     return E_NOINTERFACE;
 780 }
 781
 782 static ULONG WINAPI Test_IUnknown_AddRef(IUnknown *iface)
 783 {
 784     return 2; /* non-heap-based object */
 785 }
 786
 787 static ULONG WINAPI Test_IUnknown_Release(IUnknown *iface)
 788 {
 789     return 1; /* non-heap-based object */
 790 }
 791
 792 static const IUnknownVtbl TestUnknown_Vtbl =
 793 {
 794     Test_IUnknown_QueryInterface,
 795     Test_IUnknown_AddRef,
 796     Test_IUnknown_Release,
 797 };
 798
 799 static IUnknown Test_Unknown = { &TestUnknown_Vtbl };
 800
 801 static HRESULT WINAPI PSFactoryBuffer_QueryInterface(
 802     IPSFactoryBuffer * This,
 803     /* [in] */ REFIID riid,
 804     /* [iid_is][out] */ void **ppvObject)
 805 {
 806     if (IsEqualIID(riid, &IID_IUnknown) ||
 807         IsEqualIID(riid, &IID_IPSFactoryBuffer))
 808     {
 809         *ppvObject = This;
 810         IPSFactoryBuffer_AddRef(This);
 811         return S_OK;
 812     }
 813     return E_NOINTERFACE;
 814 }
 815
 816 static ULONG WINAPI PSFactoryBuffer_AddRef(
 817     IPSFactoryBuffer * This)
 818 {
 819     return 2;
 820 }
 821
 822 static ULONG WINAPI PSFactoryBuffer_Release(
 823     IPSFactoryBuffer * This)
 824 {
 825     return 1;
 826 }
 827
 828 static HRESULT WINAPI PSFactoryBuffer_CreateProxy(
 829     IPSFactoryBuffer * This,
 830     /* [in] */ IUnknown *pUnkOuter,
 831     /* [in] */ REFIID riid,
 832     /* [out] */ IRpcProxyBuffer **ppProxy,
 833     /* [out] */ void **ppv)
 834 {
 835     return E_NOTIMPL;
 836 }
 837
 838 static HRESULT WINAPI PSFactoryBuffer_CreateStub(
 839     IPSFactoryBuffer * This,
 840     /* [in] */ REFIID riid,
 841     /* [unique][in] */ IUnknown *pUnkServer,
 842     /* [out] */ IRpcStubBuffer **ppStub)
 843 {
 844     return E_NOTIMPL;
 845 }
 846
 847 static IPSFactoryBufferVtbl PSFactoryBufferVtbl =
 848 {
 849     PSFactoryBuffer_QueryInterface,
 850     PSFactoryBuffer_AddRef,
 851     PSFactoryBuffer_Release,
 852     PSFactoryBuffer_CreateProxy,
 853     PSFactoryBuffer_CreateStub
 854 };
 855
 856 static IPSFactoryBuffer PSFactoryBuffer = { &PSFactoryBufferVtbl };
 857
 858 static const CLSID CLSID_WineTestPSFactoryBuffer =
 859 {
 860     0x52011640,
 861     0x8164,
 862     0x4fd0,
 863     {0xa1, 0xa2, 0x5d, 0x5a, 0x36, 0x54, 0xd3, 0xbd}
 864 }; /* 52011640-8164-4fd0-a1a2-5d5a3654d3bd */
 865
 866 static void test_CoRegisterPSClsid(void)
 867 {
 868     HRESULT hr;
 869     DWORD dwRegistrationKey;
 870     IStream *stream;
 871     CLSID clsid;
 872
 873     hr = CoRegisterPSClsid(&IID_IWineTest, &CLSID_WineTestPSFactoryBuffer);
 874     ok(hr == CO_E_NOTINITIALIZED, "CoRegisterPSClsid should have returned CO_E_NOTINITIALIZED instead of 0x%08x\n", hr);
 875
 876     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 877
 878     hr = CoRegisterClassObject(&CLSID_WineTestPSFactoryBuffer, (IUnknown *)&PSFactoryBuffer,
 879         CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &dwRegistrationKey);
 880     ok_ole_success(hr, "CoRegisterClassObject");
 881
 882     hr = CoRegisterPSClsid(&IID_IWineTest, &CLSID_WineTestPSFactoryBuffer);
 883     ok_ole_success(hr, "CoRegisterPSClsid");
 884
 885     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 886     ok_ole_success(hr, "CreateStreamOnHGlobal");
 887
 888     hr = CoMarshalInterface(stream, &IID_IWineTest, &Test_Unknown, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
 889     ok(hr == E_NOTIMPL, "CoMarshalInterface should have returned E_NOTIMPL instead of 0x%08x\n", hr);
 890     IStream_Release(stream);
 891
 892     hr = CoRevokeClassObject(dwRegistrationKey);
 893     ok_ole_success(hr, "CoRevokeClassObject");
 894
 895     CoUninitialize();
 896
 897     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 898
 899     hr = CoGetPSClsid(&IID_IWineTest, &clsid);
 900     ok(hr == REGDB_E_IIDNOTREG, "CoGetPSClsid should have returned REGDB_E_IIDNOTREG instead of 0x%08x\n", hr);
 901
 902     CoUninitialize();
 903 }
 904
 905 static void test_CoGetPSClsid(void)
 906 {
 907     HRESULT hr;
 908     CLSID clsid;
 909     HKEY hkey;
 910     LONG res;
 911
 912     hr = CoGetPSClsid(&IID_IClassFactory, &clsid);
 913     ok(hr == CO_E_NOTINITIALIZED,
 914        "CoGetPSClsid should have returned CO_E_NOTINITIALIZED instead of 0x%08x\n",
 915        hr);
 916
 917     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 918
 919     hr = CoGetPSClsid(&IID_IClassFactory, &clsid);
 920     ok_ole_success(hr, "CoGetPSClsid");
 921
 922     hr = CoGetPSClsid(&IID_IWineTest, &clsid);
 923     ok(hr == REGDB_E_IIDNOTREG,
 924        "CoGetPSClsid for random IID returned 0x%08x instead of REGDB_E_IIDNOTREG\n",
 925        hr);
 926
 927     hr = CoGetPSClsid(&IID_IClassFactory, NULL);
 928     ok(hr == E_INVALIDARG,
 929        "CoGetPSClsid for null clsid returned 0x%08x instead of E_INVALIDARG\n",
 930        hr);
 931
 932     if (!pRegOverridePredefKey)
 933     {
 934         win_skip("RegOverridePredefKey not available\n");
 935         CoUninitialize();
 936         return;
 937     }
 938     hr = CoGetPSClsid(&IID_IClassFactory, &clsid);
 939     ok_ole_success(hr, "CoGetPSClsid");
 940
 941     res = RegCreateKeyEx(HKEY_CURRENT_USER, "Software\\Classes", 0, NULL, 0,
 942                          KEY_ALL_ACCESS, NULL, &hkey, NULL);
 943     ok(!res, "RegCreateKeyEx returned %d\n", res);
 944
 945     res = pRegOverridePredefKey(HKEY_CLASSES_ROOT, hkey);
 946     ok(!res, "RegOverridePredefKey returned %d\n", res);
 947
 948     hr = CoGetPSClsid(&IID_IClassFactory, &clsid);
 949     ok_ole_success(hr, "CoGetPSClsid");
 950
 951     res = pRegOverridePredefKey(HKEY_CLASSES_ROOT, NULL);
 952     ok(!res, "RegOverridePredefKey returned %d\n", res);
 953
 954     RegCloseKey(hkey);
 955     CoUninitialize();
 956 }
 957
 958 /* basic test, mainly for invalid arguments. see marshal.c for more */
 959 static void test_CoUnmarshalInterface(void)
 960 {
 961     IUnknown *pProxy;
 962     IStream *pStream;
 963     HRESULT hr;
 964
 965     hr = CoUnmarshalInterface(NULL, &IID_IUnknown, (void **)&pProxy);
 966     ok(hr == E_INVALIDARG, "CoUnmarshalInterface should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 967
 968     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
 969     ok_ole_success(hr, "CreateStreamOnHGlobal");
 970
 971     hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)&pProxy);
 972     todo_wine
 973     ok(hr == CO_E_NOTINITIALIZED, "CoUnmarshalInterface should have returned CO_E_NOTINITIALIZED instead of 0x%08x\n", hr);
 974
 975     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 976
 977     hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)&pProxy);
 978     ok(hr == STG_E_READFAULT, "CoUnmarshalInterface should have returned STG_E_READFAULT instead of 0x%08x\n", hr);
 979
 980     CoUninitialize();
 981
 982     hr = CoUnmarshalInterface(pStream, &IID_IUnknown, NULL);
 983     ok(hr == E_INVALIDARG, "CoUnmarshalInterface should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 984
 985     IStream_Release(pStream);
 986 }
 987
 988 static void test_CoGetInterfaceAndReleaseStream(void)
 989 {
 990     HRESULT hr;
 991     IUnknown *pUnk;
 992
 993     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 994
 995     hr = CoGetInterfaceAndReleaseStream(NULL, &IID_IUnknown, (void**)&pUnk);
 996     ok(hr == E_INVALIDARG, "hr %08x\n", hr);
 997
 998     CoUninitialize();
 999 }
1000
1001 /* basic test, mainly for invalid arguments. see marshal.c for more */
1002 static void test_CoMarshalInterface(void)
1003 {
1004     IStream *pStream;
1005     HRESULT hr;
1006     static const LARGE_INTEGER llZero;
1007
1008     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1009
1010     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1011     ok_ole_success(hr, "CreateStreamOnHGlobal");
1012
1013     hr = CoMarshalInterface(pStream, &IID_IUnknown, NULL, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1014     ok(hr == E_INVALIDARG, "CoMarshalInterface should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1015
1016     hr = CoMarshalInterface(NULL, &IID_IUnknown, (IUnknown *)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1017     ok(hr == E_INVALIDARG, "CoMarshalInterface should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1018
1019     hr = CoMarshalInterface(pStream, &IID_IUnknown, (IUnknown *)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1020     ok_ole_success(hr, "CoMarshalInterface");
1021
1022     /* stream not rewound */
1023     hr = CoReleaseMarshalData(pStream);
1024     ok(hr == STG_E_READFAULT, "CoReleaseMarshalData should have returned STG_E_READFAULT instead of 0x%08x\n", hr);
1025
1026     hr = IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
1027     ok_ole_success(hr, "IStream_Seek");
1028
1029     hr = CoReleaseMarshalData(pStream);
1030     ok_ole_success(hr, "CoReleaseMarshalData");
1031
1032     IStream_Release(pStream);
1033
1034     CoUninitialize();
1035 }
1036
1037 static void test_CoMarshalInterThreadInterfaceInStream(void)
1038 {
1039     IStream *pStream;
1040     HRESULT hr;
1041     IClassFactory *pProxy;
1042
1043     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1044
1045     cLocks = 0;
1046
1047     hr = CoMarshalInterThreadInterfaceInStream(&IID_IUnknown, (IUnknown *)&Test_ClassFactory, NULL);
1048     ok(hr == E_INVALIDARG, "CoMarshalInterThreadInterfaceInStream should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1049
1050     hr = CoMarshalInterThreadInterfaceInStream(&IID_IUnknown, NULL, &pStream);
1051     ok(hr == E_INVALIDARG, "CoMarshalInterThreadInterfaceInStream should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1052
1053     ok_no_locks();
1054
1055     hr = CoMarshalInterThreadInterfaceInStream(&IID_IUnknown, (IUnknown *)&Test_ClassFactory, &pStream);
1056     ok_ole_success(hr, "CoMarshalInterThreadInterfaceInStream");
1057
1058     ok_more_than_one_lock();
1059
1060     hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
1061     ok_ole_success(hr, "CoUnmarshalInterface");
1062
1063     IClassFactory_Release(pProxy);
1064     IStream_Release(pStream);
1065
1066     ok_no_locks();
1067
1068     CoUninitialize();
1069 }
1070
1071 static void test_CoRegisterClassObject(void)
1072 {
1073     DWORD cookie;
1074     HRESULT hr;
1075     IClassFactory *pcf;
1076
1077     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1078
1079     /* CLSCTX_INPROC_SERVER */
1080     hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&Test_ClassFactory,
1081                                CLSCTX_INPROC_SERVER, REGCLS_SINGLEUSE, &cookie);
1082     ok_ole_success(hr, "CoRegisterClassObject");
1083     hr = CoRevokeClassObject(cookie);
1084     ok_ole_success(hr, "CoRevokeClassObject");
1085
1086     hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&Test_ClassFactory,
1087                                CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &cookie);
1088     ok_ole_success(hr, "CoRegisterClassObject");
1089     hr = CoRevokeClassObject(cookie);
1090     ok_ole_success(hr, "CoRevokeClassObject");
1091
1092     hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&Test_ClassFactory,
1093                                CLSCTX_INPROC_SERVER, REGCLS_MULTI_SEPARATE, &cookie);
1094     ok_ole_success(hr, "CoRegisterClassObject");
1095     hr = CoRevokeClassObject(cookie);
1096     ok_ole_success(hr, "CoRevokeClassObject");
1097
1098     /* CLSCTX_LOCAL_SERVER */
1099     hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&Test_ClassFactory,
1100                                CLSCTX_LOCAL_SERVER, REGCLS_SINGLEUSE, &cookie);
1101     ok_ole_success(hr, "CoRegisterClassObject");
1102     hr = CoRevokeClassObject(cookie);
1103     ok_ole_success(hr, "CoRevokeClassObject");
1104
1105     hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&Test_ClassFactory,
1106                                CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE, &cookie);
1107     ok_ole_success(hr, "CoRegisterClassObject");
1108     hr = CoRevokeClassObject(cookie);
1109     ok_ole_success(hr, "CoRevokeClassObject");
1110
1111     hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&Test_ClassFactory,
1112                                CLSCTX_LOCAL_SERVER, REGCLS_MULTI_SEPARATE, &cookie);
1113     ok_ole_success(hr, "CoRegisterClassObject");
1114     hr = CoRevokeClassObject(cookie);
1115     ok_ole_success(hr, "CoRevokeClassObject");
1116
1117     /* CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER */
1118     hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&Test_ClassFactory,
1119                                CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER, REGCLS_SINGLEUSE, &cookie);
1120     ok_ole_success(hr, "CoRegisterClassObject");
1121     hr = CoRevokeClassObject(cookie);
1122     ok_ole_success(hr, "CoRevokeClassObject");
1123
1124     /* test whether an object that doesn't support IClassFactory can be
1125      * registered for CLSCTX_LOCAL_SERVER */
1126     hr = CoRegisterClassObject(&CLSID_WineOOPTest, &Test_Unknown,
1127                                CLSCTX_LOCAL_SERVER, REGCLS_SINGLEUSE, &cookie);
1128     ok_ole_success(hr, "CoRegisterClassObject");
1129     hr = CoRevokeClassObject(cookie);
1130     ok_ole_success(hr, "CoRevokeClassObject");
1131
1132     /* test whether registered class becomes invalid when apartment is destroyed */
1133     hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&Test_ClassFactory,
1134                                CLSCTX_INPROC_SERVER, REGCLS_SINGLEUSE, &cookie);
1135     ok_ole_success(hr, "CoRegisterClassObject");
1136
1137     CoUninitialize();
1138     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1139
1140     hr = CoGetClassObject(&CLSID_WineOOPTest, CLSCTX_INPROC_SERVER, NULL,
1141                           &IID_IClassFactory, (void **)&pcf);
1142     ok(hr == REGDB_E_CLASSNOTREG, "object registered in an apartment shouldn't accessible after it is destroyed\n");
1143
1144     /* crashes with at least win9x DCOM! */
1145     if (0)
1146         CoRevokeClassObject(cookie);
1147
1148     CoUninitialize();
1149 }
1150
1151 static HRESULT get_class_object(CLSCTX clsctx)
1152 {
1153     HRESULT hr;
1154     IClassFactory *pcf;
1155
1156     hr = CoGetClassObject(&CLSID_WineOOPTest, clsctx, NULL, &IID_IClassFactory,
1157                           (void **)&pcf);
1158
1159     if (SUCCEEDED(hr))
1160         IClassFactory_Release(pcf);
1161
1162     return hr;
1163 }
1164
1165 static DWORD CALLBACK get_class_object_thread(LPVOID pv)
1166 {
1167     CLSCTX clsctx = (CLSCTX)(DWORD_PTR)pv;
1168     HRESULT hr;
1169
1170     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1171
1172     hr = get_class_object(clsctx);
1173
1174     CoUninitialize();
1175
1176     return hr;
1177 }
1178
1179 static DWORD CALLBACK get_class_object_proxy_thread(LPVOID pv)
1180 {
1181     CLSCTX clsctx = (CLSCTX)(DWORD_PTR)pv;
1182     HRESULT hr;
1183     IClassFactory *pcf;
1184     IMultiQI *pMQI;
1185
1186     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1187
1188     hr = CoGetClassObject(&CLSID_WineOOPTest, clsctx, NULL, &IID_IClassFactory,
1189                           (void **)&pcf);
1190
1191     if (SUCCEEDED(hr))
1192     {
1193         hr = IClassFactory_QueryInterface(pcf, &IID_IMultiQI, (void **)&pMQI);
1194         if (SUCCEEDED(hr))
1195             IMultiQI_Release(pMQI);
1196         IClassFactory_Release(pcf);
1197     }
1198
1199     CoUninitialize();
1200
1201     return hr;
1202 }
1203
1204 static DWORD CALLBACK register_class_object_thread(LPVOID pv)
1205 {
1206     HRESULT hr;
1207     DWORD cookie;
1208
1209     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1210
1211     hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&Test_ClassFactory,
1212                                CLSCTX_INPROC_SERVER, REGCLS_SINGLEUSE, &cookie);
1213
1214     CoUninitialize();
1215
1216     return hr;
1217 }
1218
1219 static DWORD CALLBACK revoke_class_object_thread(LPVOID pv)
1220 {
1221     DWORD cookie = (DWORD_PTR)pv;
1222     HRESULT hr;
1223
1224     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1225
1226     hr = CoRevokeClassObject(cookie);
1227
1228     CoUninitialize();
1229
1230     return hr;
1231 }
1232
1233 static void test_registered_object_thread_affinity(void)
1234 {
1235     HRESULT hr;
1236     DWORD cookie;
1237     HANDLE thread;
1238     DWORD tid;
1239     DWORD exitcode;
1240
1241     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1242
1243     /* CLSCTX_INPROC_SERVER */
1244
1245     hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&Test_ClassFactory,
1246                                CLSCTX_INPROC_SERVER, REGCLS_SINGLEUSE, &cookie);
1247     ok_ole_success(hr, "CoRegisterClassObject");
1248
1249     thread = CreateThread(NULL, 0, get_class_object_thread, (LPVOID)CLSCTX_INPROC_SERVER, 0, &tid);
1250     ok(thread != NULL, "CreateThread failed with error %d\n", GetLastError());
1251     ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
1252     GetExitCodeThread(thread, &exitcode);
1253     hr = exitcode;
1254     ok(hr == REGDB_E_CLASSNOTREG, "CoGetClassObject on inproc object "
1255        "registered in different thread should return REGDB_E_CLASSNOTREG "
1256        "instead of 0x%08x\n", hr);
1257
1258     hr = get_class_object(CLSCTX_INPROC_SERVER);
1259     ok(hr == S_OK, "CoGetClassObject on inproc object registered in same "
1260        "thread should return S_OK instead of 0x%08x\n", hr);
1261
1262     thread = CreateThread(NULL, 0, register_class_object_thread, NULL, 0, &tid);
1263     ok(thread != NULL, "CreateThread failed with error %d\n", GetLastError());
1264     ok ( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
1265     GetExitCodeThread(thread, &exitcode);
1266     hr = exitcode;
1267     ok(hr == S_OK, "CoRegisterClassObject with same CLSID but in different thread should return S_OK instead of 0x%08x\n", hr);
1268
1269     hr = CoRevokeClassObject(cookie);
1270     ok_ole_success(hr, "CoRevokeClassObject");
1271
1272     /* CLSCTX_LOCAL_SERVER */
1273
1274     hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&Test_ClassFactory,
1275                                CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE, &cookie);
1276     ok_ole_success(hr, "CoRegisterClassObject");
1277
1278     thread = CreateThread(NULL, 0, get_class_object_proxy_thread, (LPVOID)CLSCTX_LOCAL_SERVER, 0, &tid);
1279     ok(thread != NULL, "CreateThread failed with error %d\n", GetLastError());
1280     while (MsgWaitForMultipleObjects(1, &thread, FALSE, 10000, QS_ALLINPUT) == WAIT_OBJECT_0 + 1)
1281     {
1282         MSG msg;
1283         while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
1284         {
1285             TranslateMessage(&msg);
1286             DispatchMessageA(&msg);
1287         }
1288     }
1289     GetExitCodeThread(thread, &exitcode);
1290     hr = exitcode;
1291     ok(hr == S_OK, "CoGetClassObject on local server object "
1292        "registered in different thread should return S_OK "
1293        "instead of 0x%08x\n", hr);
1294
1295     hr = get_class_object(CLSCTX_LOCAL_SERVER);
1296     ok(hr == S_OK, "CoGetClassObject on local server object registered in same "
1297        "thread should return S_OK instead of 0x%08x\n", hr);
1298
1299     thread = CreateThread(NULL, 0, revoke_class_object_thread, (LPVOID)(DWORD_PTR)cookie, 0, &tid);
1300     ok(thread != NULL, "CreateThread failed with error %d\n", GetLastError());
1301     ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
1302     GetExitCodeThread(thread, &exitcode);
1303     hr = exitcode;
1304     ok(hr == RPC_E_WRONG_THREAD, "CoRevokeClassObject called from different "
1305        "thread to where registered should return RPC_E_WRONG_THREAD instead of 0x%08x\n", hr);
1306
1307     thread = CreateThread(NULL, 0, register_class_object_thread, NULL, 0, &tid);
1308     ok(thread != NULL, "CreateThread failed with error %d\n", GetLastError());
1309     ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
1310     GetExitCodeThread(thread, &exitcode);
1311     hr = exitcode;
1312     ok(hr == S_OK, "CoRegisterClassObject with same CLSID but in different "
1313         "thread should return S_OK instead of 0x%08x\n", hr);
1314
1315     hr = CoRevokeClassObject(cookie);
1316     ok_ole_success(hr, "CoRevokeClassObject");
1317
1318     CoUninitialize();
1319 }
1320
1321 static DWORD CALLBACK free_libraries_thread(LPVOID p)
1322 {
1323     CoFreeUnusedLibraries();
1324     return 0;
1325 }
1326
1327 static inline BOOL is_module_loaded(const char *module)
1328 {
1329     return GetModuleHandle(module) != 0;
1330 }
1331
1332 static void test_CoFreeUnusedLibraries(void)
1333 {
1334     HRESULT hr;
1335     IUnknown *pUnk;
1336     DWORD tid;
1337     HANDLE thread;
1338
1339     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1340
1341     ok(!is_module_loaded("urlmon.dll"), "urlmon.dll shouldn't be loaded\n");
1342
1343     hr = CoCreateInstance(&CLSID_FileProtocol, NULL, CLSCTX_INPROC_SERVER, &IID_IInternetProtocol, (void **)&pUnk);
1344     if (hr == REGDB_E_CLASSNOTREG)
1345     {
1346         skip("IE not installed so can't run CoFreeUnusedLibraries test\n");
1347         CoUninitialize();
1348         return;
1349     }
1350     ok_ole_success(hr, "CoCreateInstance");
1351
1352     ok(is_module_loaded("urlmon.dll"), "urlmon.dll should be loaded\n");
1353
1354     ok(pUnk != NULL ||
1355        broken(pUnk == NULL), /* win9x */
1356        "Expected a valid pointer\n");
1357     if (pUnk)
1358         IUnknown_Release(pUnk);
1359
1360     ok(is_module_loaded("urlmon.dll"), "urlmon.dll should be loaded\n");
1361
1362     thread = CreateThread(NULL, 0, free_libraries_thread, NULL, 0, &tid);
1363     ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
1364     CloseHandle(thread);
1365
1366     ok(is_module_loaded("urlmon.dll"), "urlmon.dll should be loaded\n");
1367
1368     CoFreeUnusedLibraries();
1369
1370     ok(!is_module_loaded("urlmon.dll"), "urlmon.dll shouldn't be loaded\n");
1371
1372     CoUninitialize();
1373 }
1374
1375 static void test_CoGetObjectContext(void)
1376 {
1377     HRESULT hr;
1378     ULONG refs;
1379     IComThreadingInfo *pComThreadingInfo;
1380     IContextCallback *pContextCallback;
1381     IObjContext *pObjContext;
1382     APTTYPE apttype;
1383     THDTYPE thdtype;
1384     struct info info;
1385     HANDLE thread;
1386     DWORD tid, exitcode;
1387
1388     if (!pCoGetObjectContext)
1389     {
1390         skip("CoGetObjectContext not present\n");
1391         return;
1392     }
1393
1394     hr = pCoGetObjectContext(&IID_IComThreadingInfo, (void **)&pComThreadingInfo);
1395     ok(hr == CO_E_NOTINITIALIZED, "CoGetObjectContext should have returned CO_E_NOTINITIALIZED instead of 0x%08x\n", hr);
1396     ok(pComThreadingInfo == NULL, "pComThreadingInfo should have been set to NULL\n");
1397
1398     /* show that COM doesn't have to be initialized for multi-threaded apartments if another
1399        thread has already done so */
1400
1401     info.wait = CreateEvent(NULL, TRUE, FALSE, NULL);
1402     ok(info.wait != NULL, "CreateEvent failed with error %d\n", GetLastError());
1403
1404     info.stop = CreateEvent(NULL, TRUE, FALSE, NULL);
1405     ok(info.stop != NULL, "CreateEvent failed with error %d\n", GetLastError());
1406
1407     thread = CreateThread(NULL, 0, ole_initialize_thread, &info, 0, &tid);
1408     ok(thread != NULL, "CreateThread failed with error %d\n", GetLastError());
1409
1410     ok( !WaitForSingleObject(info.wait, 10000), "wait timed out\n" );
1411
1412     pComThreadingInfo = NULL;
1413     hr = pCoGetObjectContext(&IID_IComThreadingInfo, (void **)&pComThreadingInfo);
1414     ok(hr == S_OK, "Expected S_OK, got 0x%08x\n", hr);
1415     IComThreadingInfo_Release(pComThreadingInfo);
1416
1417     SetEvent(info.stop);
1418     ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
1419
1420     GetExitCodeThread(thread, &exitcode);
1421     hr = exitcode;
1422     ok(hr == S_OK, "thread should have returned S_OK instead of 0x%08x\n", hr);
1423
1424     CloseHandle(thread);
1425     CloseHandle(info.wait);
1426     CloseHandle(info.stop);
1427
1428     pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1429
1430     hr = pCoGetObjectContext(&IID_IComThreadingInfo, (void **)&pComThreadingInfo);
1431     ok_ole_success(hr, "CoGetObjectContext");
1432
1433     hr = IComThreadingInfo_GetCurrentApartmentType(pComThreadingInfo, &apttype);
1434     ok_ole_success(hr, "IComThreadingInfo_GetCurrentApartmentType");
1435     ok(apttype == APTTYPE_MAINSTA, "apartment type should be APTTYPE_MAINSTA instead of %d\n", apttype);
1436
1437     hr = IComThreadingInfo_GetCurrentThreadType(pComThreadingInfo, &thdtype);
1438     ok_ole_success(hr, "IComThreadingInfo_GetCurrentThreadType");
1439     ok(thdtype == THDTYPE_PROCESSMESSAGES, "thread type should be THDTYPE_PROCESSMESSAGES instead of %d\n", thdtype);
1440
1441     refs = IComThreadingInfo_Release(pComThreadingInfo);
1442     ok(refs == 0, "pComThreadingInfo should have 0 refs instead of %d refs\n", refs);
1443
1444     hr = pCoGetObjectContext(&IID_IContextCallback, (void **)&pContextCallback);
1445     ok_ole_success(hr, "CoGetObjectContext(ContextCallback)");
1446
1447     if (hr == S_OK)
1448     {
1449         refs = IContextCallback_Release(pContextCallback);
1450         ok(refs == 0, "pContextCallback should have 0 refs instead of %d refs\n", refs);
1451     }
1452
1453     CoUninitialize();
1454
1455     pCoInitializeEx(NULL, COINIT_MULTITHREADED);
1456
1457     hr = pCoGetObjectContext(&IID_IComThreadingInfo, (void **)&pComThreadingInfo);
1458     ok_ole_success(hr, "CoGetObjectContext");
1459
1460     hr = IComThreadingInfo_GetCurrentApartmentType(pComThreadingInfo, &apttype);
1461     ok_ole_success(hr, "IComThreadingInfo_GetCurrentApartmentType");
1462     ok(apttype == APTTYPE_MTA, "apartment type should be APTTYPE_MTA instead of %d\n", apttype);
1463
1464     hr = IComThreadingInfo_GetCurrentThreadType(pComThreadingInfo, &thdtype);
1465     ok_ole_success(hr, "IComThreadingInfo_GetCurrentThreadType");
1466     ok(thdtype == THDTYPE_BLOCKMESSAGES, "thread type should be THDTYPE_BLOCKMESSAGES instead of %d\n", thdtype);
1467
1468     refs = IComThreadingInfo_Release(pComThreadingInfo);
1469     ok(refs == 0, "pComThreadingInfo should have 0 refs instead of %d refs\n", refs);
1470
1471     hr = pCoGetObjectContext(&IID_IContextCallback, (void **)&pContextCallback);
1472     ok_ole_success(hr, "CoGetObjectContext(ContextCallback)");
1473
1474     if (hr == S_OK)
1475     {
1476         refs = IContextCallback_Release(pContextCallback);
1477         ok(refs == 0, "pContextCallback should have 0 refs instead of %d refs\n", refs);
1478     }
1479
1480     hr = pCoGetObjectContext(&IID_IObjContext, (void **)&pObjContext);
1481     ok_ole_success(hr, "CoGetObjectContext");
1482
1483     refs = IObjContext_Release(pObjContext);
1484     ok(refs == 0, "pObjContext should have 0 refs instead of %d refs\n", refs);
1485
1486     CoUninitialize();
1487 }
1488
1489 typedef struct {
1490     IUnknown IUnknown_iface;
1491     LONG refs;
1492 } Test_CallContext;
1493
1494 static inline Test_CallContext *impl_from_IUnknown(IUnknown *iface)
1495 {
1496     return CONTAINING_RECORD(iface, Test_CallContext, IUnknown_iface);
1497 }
1498
1499 static HRESULT WINAPI Test_CallContext_QueryInterface(
1500     IUnknown *iface,
1501     REFIID riid,
1502     LPVOID *ppvObj)
1503 {
1504     if (ppvObj == NULL) return E_POINTER;
1505
1506     if (IsEqualGUID(riid, &IID_IUnknown))
1507     {
1508         *ppvObj = iface;
1509         IUnknown_AddRef(iface);
1510         return S_OK;
1511     }
1512
1513     *ppvObj = NULL;
1514     return E_NOINTERFACE;
1515 }
1516
1517 static ULONG WINAPI Test_CallContext_AddRef(IUnknown *iface)
1518 {
1519     Test_CallContext *This = impl_from_IUnknown(iface);
1520     return InterlockedIncrement(&This->refs);
1521 }
1522
1523 static ULONG WINAPI Test_CallContext_Release(IUnknown *iface)
1524 {
1525     Test_CallContext *This = impl_from_IUnknown(iface);
1526     ULONG refs = InterlockedDecrement(&This->refs);
1527     if (!refs)
1528         HeapFree(GetProcessHeap(), 0, This);
1529     return refs;
1530 }
1531
1532 static const IUnknownVtbl TestCallContext_Vtbl =
1533 {
1534     Test_CallContext_QueryInterface,
1535     Test_CallContext_AddRef,
1536     Test_CallContext_Release
1537 };
1538
1539 static void test_CoGetCallContext(void)
1540 {
1541     HRESULT hr;
1542     ULONG refs;
1543     IUnknown *pUnk;
1544     Test_CallContext *test_object;
1545
1546     if (!pCoSwitchCallContext)
1547     {
1548         skip("CoSwitchCallContext not present\n");
1549         return;
1550     }
1551
1552     CoInitialize(NULL);
1553
1554     test_object = HeapAlloc(GetProcessHeap(), 0, sizeof(Test_CallContext));
1555     test_object->IUnknown_iface.lpVtbl = &TestCallContext_Vtbl;
1556     test_object->refs = 1;
1557
1558     hr = CoGetCallContext(&IID_IUnknown, (void**)&pUnk);
1559     ok(hr == RPC_E_CALL_COMPLETE, "Expected RPC_E_CALL_COMPLETE, got 0x%08x\n", hr);
1560
1561     pUnk = (IUnknown*)0xdeadbeef;
1562     hr = pCoSwitchCallContext(&test_object->IUnknown_iface, &pUnk);
1563     ok_ole_success(hr, "CoSwitchCallContext");
1564     ok(pUnk == NULL, "expected NULL, got %p\n", pUnk);
1565     refs = IUnknown_AddRef(&test_object->IUnknown_iface);
1566     ok(refs == 2, "Expected refcount 2, got %d\n", refs);
1567     IUnknown_Release(&test_object->IUnknown_iface);
1568
1569     pUnk = (IUnknown*)0xdeadbeef;
1570     hr = CoGetCallContext(&IID_IUnknown, (void**)&pUnk);
1571     ok_ole_success(hr, "CoGetCallContext");
1572     ok(pUnk == &test_object->IUnknown_iface, "expected %p, got %p\n",
1573        &test_object->IUnknown_iface, pUnk);
1574     refs = IUnknown_AddRef(&test_object->IUnknown_iface);
1575     ok(refs == 3, "Expected refcount 3, got %d\n", refs);
1576     IUnknown_Release(&test_object->IUnknown_iface);
1577     IUnknown_Release(pUnk);
1578
1579     pUnk = (IUnknown*)0xdeadbeef;
1580     hr = pCoSwitchCallContext(NULL, &pUnk);
1581     ok_ole_success(hr, "CoSwitchCallContext");
1582     ok(pUnk == &test_object->IUnknown_iface, "expected %p, got %p\n",
1583        &test_object->IUnknown_iface, pUnk);
1584     refs = IUnknown_AddRef(&test_object->IUnknown_iface);
1585     ok(refs == 2, "Expected refcount 2, got %d\n", refs);
1586     IUnknown_Release(&test_object->IUnknown_iface);
1587
1588     hr = CoGetCallContext(&IID_IUnknown, (void**)&pUnk);
1589     ok(hr == RPC_E_CALL_COMPLETE, "Expected RPC_E_CALL_COMPLETE, got 0x%08x\n", hr);
1590
1591     IUnknown_Release(&test_object->IUnknown_iface);
1592
1593     CoUninitialize();
1594 }
1595
1596 static void test_CoGetContextToken(void)
1597 {
1598     HRESULT hr;
1599     ULONG refs;
1600     ULONG_PTR token;
1601     IObjContext *ctx;
1602     struct info info;
1603     HANDLE thread;
1604     DWORD tid, exitcode;
1605
1606     if (!pCoGetContextToken)
1607     {
1608         win_skip("CoGetContextToken not present\n");
1609         return;
1610     }
1611
1612     token = 0xdeadbeef;
1613     hr = pCoGetContextToken(&token);
1614     ok(hr == CO_E_NOTINITIALIZED, "Expected CO_E_NOTINITIALIZED, got 0x%08x\n", hr);
1615     ok(token == 0xdeadbeef, "Expected 0, got 0x%lx\n", token);
1616
1617     /* show that COM doesn't have to be initialized for multi-threaded apartments if another
1618        thread has already done so */
1619
1620     info.wait = CreateEvent(NULL, TRUE, FALSE, NULL);
1621     ok(info.wait != NULL, "CreateEvent failed with error %d\n", GetLastError());
1622
1623     info.stop = CreateEvent(NULL, TRUE, FALSE, NULL);
1624     ok(info.stop != NULL, "CreateEvent failed with error %d\n", GetLastError());
1625
1626     thread = CreateThread(NULL, 0, ole_initialize_thread, &info, 0, &tid);
1627     ok(thread != NULL, "CreateThread failed with error %d\n", GetLastError());
1628
1629     ok( !WaitForSingleObject(info.wait, 10000), "wait timed out\n" );
1630
1631     token = 0;
1632     hr = pCoGetContextToken(&token);
1633     ok(hr == S_OK, "Expected S_OK, got 0x%08x\n", hr);
1634
1635     SetEvent(info.stop);
1636     ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
1637
1638     GetExitCodeThread(thread, &exitcode);
1639     hr = exitcode;
1640     ok(hr == S_OK, "thread should have returned S_OK instead of 0x%08x\n", hr);
1641
1642     CloseHandle(thread);
1643     CloseHandle(info.wait);
1644     CloseHandle(info.stop);
1645
1646     CoInitialize(NULL);
1647
1648     hr = pCoGetContextToken(NULL);
1649     ok(hr == E_POINTER, "Expected E_POINTER, got 0x%08x\n", hr);
1650
1651     token = 0;
1652     hr = pCoGetContextToken(&token);
1653     ok(hr == S_OK, "Expected S_OK, got 0x%08x\n", hr);
1654     ok(token, "Expected token != 0\n");
1655
1656     refs = IUnknown_AddRef((IUnknown *)token);
1657     todo_wine ok(refs == 1, "Expected 1, got %u\n", refs);
1658
1659     hr = pCoGetObjectContext(&IID_IObjContext, (void **)&ctx);
1660     ok(hr == S_OK, "Expected S_OK, got 0x%08x\n", hr);
1661     todo_wine ok(ctx == (IObjContext *)token, "Expected interface pointers to be the same\n");
1662
1663     refs = IUnknown_AddRef((IUnknown *)ctx);
1664     todo_wine ok(refs == 3, "Expected 3, got %u\n", refs);
1665
1666     refs = IUnknown_Release((IUnknown *)ctx);
1667     todo_wine ok(refs == 2, "Expected 2, got %u\n", refs);
1668
1669     refs = IUnknown_Release((IUnknown *)token);
1670     ok(refs == 1, "Expected 1, got %u\n", refs);
1671
1672     /* CoGetContextToken does not add a reference */
1673     token = 0;
1674     hr = pCoGetContextToken(&token);
1675     ok(hr == S_OK, "Expected S_OK, got 0x%08x\n", hr);
1676     ok(token, "Expected token != 0\n");
1677     todo_wine ok(ctx == (IObjContext *)token, "Expected interface pointers to be the same\n");
1678
1679     refs = IUnknown_AddRef((IUnknown *)ctx);
1680     ok(refs == 2, "Expected 1, got %u\n", refs);
1681
1682     refs = IUnknown_Release((IUnknown *)ctx);
1683     ok(refs == 1, "Expected 0, got %u\n", refs);
1684
1685     refs = IUnknown_Release((IUnknown *)ctx);
1686     ok(refs == 0, "Expected 0, got %u\n", refs);
1687
1688     CoUninitialize();
1689 }
1690
1691 static void test_CoGetTreatAsClass(void)
1692 {
1693     HRESULT hr;
1694     CLSID out;
1695     static GUID deadbeef = {0xdeadbeef,0xdead,0xbeef,{0xde,0xad,0xbe,0xef,0xde,0xad,0xbe,0xef}};
1696
1697     if (!pCoGetTreatAsClass)
1698     {
1699         win_skip("CoGetTreatAsClass not present\n");
1700         return;
1701     }
1702     hr = pCoGetTreatAsClass(&deadbeef,&out);
1703     ok (hr == S_FALSE, "expected S_FALSE got %x\n",hr);
1704     ok (IsEqualGUID(&out,&deadbeef), "expected to get same clsid back\n");
1705 }
1706
1707 static void test_CoInitializeEx(void)
1708 {
1709     HRESULT hr;
1710
1711     hr = pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1712     ok(hr == S_OK, "CoInitializeEx failed with error 0x%08x\n", hr);
1713
1714     /* Calling OleInitialize for the first time should yield S_OK even with
1715      * apartment already initialized by previous CoInitialize(Ex) calls. */
1716     hr = OleInitialize(NULL);
1717     ok(hr == S_OK, "OleInitialize failed with error 0x%08x\n", hr);
1718
1719     /* Subsequent calls to OleInitialize should return S_FALSE */
1720     hr = OleInitialize(NULL);
1721     ok(hr == S_FALSE, "Expected S_FALSE, hr = 0x%08x\n", hr);
1722
1723     /* Cleanup */
1724     CoUninitialize();
1725     OleUninitialize();
1726 }
1727
1728 static void test_OleRegGetMiscStatus(void)
1729 {
1730     ULONG_PTR cookie;
1731     HANDLE handle;
1732     DWORD status;
1733     HRESULT hr;
1734
1735     hr = OleRegGetMiscStatus(&CLSID_Testclass, DVASPECT_ICON, NULL);
1736     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1737
1738     status = 0xdeadbeef;
1739     hr = OleRegGetMiscStatus(&CLSID_Testclass, DVASPECT_ICON, &status);
1740     ok(hr == REGDB_E_CLASSNOTREG, "got 0x%08x\n", hr);
1741     ok(status == 0, "got 0x%08x\n", status);
1742
1743     status = -1;
1744     hr = OleRegGetMiscStatus(&CLSID_StdFont, DVASPECT_ICON, &status);
1745     ok(hr == S_OK, "got 0x%08x\n", hr);
1746     ok(status == 0, "got 0x%08x\n", status);
1747
1748     if ((handle = activate_context(actctx_manifest, &cookie)))
1749     {
1750         status = 0;
1751         hr = OleRegGetMiscStatus(&CLSID_Testclass, DVASPECT_ICON, &status);
1752 todo_wine {
1753         ok(hr == S_OK, "got 0x%08x\n", hr);
1754         ok(status == OLEMISC_RECOMPOSEONRESIZE, "got 0x%08x\n", status);
1755 }
1756         /* context data takes precedence over registration info */
1757         status = 0;
1758         hr = OleRegGetMiscStatus(&CLSID_StdFont, DVASPECT_ICON, &status);
1759         ok(hr == S_OK, "got 0x%08x\n", hr);
1760 todo_wine
1761         ok(status == OLEMISC_RECOMPOSEONRESIZE, "got 0x%08x\n", status);
1762
1763         /* there's no such attribute in context */
1764         status = -1;
1765         hr = OleRegGetMiscStatus(&CLSID_Testclass, DVASPECT_DOCPRINT, &status);
1766 todo_wine
1767         ok(hr == S_OK, "got 0x%08x\n", hr);
1768         ok(status == 0, "got 0x%08x\n", status);
1769
1770         pDeactivateActCtx(0, cookie);
1771         pReleaseActCtx(handle);
1772     }
1773 }
1774
1775 static void init_funcs(void)
1776 {
1777     HMODULE hOle32 = GetModuleHandleA("ole32");
1778     HMODULE hAdvapi32 = GetModuleHandleA("advapi32");
1779     HMODULE hkernel32 = GetModuleHandleA("kernel32");
1780
1781     pCoGetObjectContext = (void*)GetProcAddress(hOle32, "CoGetObjectContext");
1782     pCoSwitchCallContext = (void*)GetProcAddress(hOle32, "CoSwitchCallContext");
1783     pCoGetTreatAsClass = (void*)GetProcAddress(hOle32,"CoGetTreatAsClass");
1784     pCoGetContextToken = (void*)GetProcAddress(hOle32, "CoGetContextToken");
1785     pRegOverridePredefKey = (void*)GetProcAddress(hAdvapi32, "RegOverridePredefKey");
1786     pCoInitializeEx = (void*)GetProcAddress(hOle32, "CoInitializeEx");
1787
1788     pActivateActCtx = (void*)GetProcAddress(hkernel32, "ActivateActCtx");
1789     pCreateActCtxW = (void*)GetProcAddress(hkernel32, "CreateActCtxW");
1790     pDeactivateActCtx = (void*)GetProcAddress(hkernel32, "DeactivateActCtx");
1791     pReleaseActCtx = (void*)GetProcAddress(hkernel32, "ReleaseActCtx");
1792 }
1793
1794 START_TEST(compobj)
1795 {
1796     init_funcs();
1797
1798     if (!pCoInitializeEx)
1799     {
1800         trace("You need DCOM95 installed to run this test\n");
1801         return;
1802     }
1803
1804     test_ProgIDFromCLSID();
1805     test_CLSIDFromProgID();
1806     test_CLSIDFromString();
1807     test_StringFromGUID2();
1808     test_CoCreateInstance();
1809     test_ole_menu();
1810     test_CoGetClassObject();
1811     test_CoRegisterMessageFilter();
1812     test_CoRegisterPSClsid();
1813     test_CoGetPSClsid();
1814     test_CoUnmarshalInterface();
1815     test_CoGetInterfaceAndReleaseStream();
1816     test_CoMarshalInterface();
1817     test_CoMarshalInterThreadInterfaceInStream();
1818     test_CoRegisterClassObject();
1819     test_registered_object_thread_affinity();
1820     test_CoFreeUnusedLibraries();
1821     test_CoGetObjectContext();
1822     test_CoGetCallContext();
1823     test_CoGetContextToken();
1824     test_CoGetTreatAsClass();
1825     test_CoInitializeEx();
1826     test_OleRegGetMiscStatus();
1827 }