rostests/winetests/msctf/inputprocessor.c

   1 /*
   2  * Unit tests for ITfInputProcessor
   3  *
   4  * Copyright 2009 Aric Stewart, CodeWeavers
   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 #include <stdio.h>
  22
  23 #define COBJMACROS
  24 #define CONST_VTABLE
  25 #include "wine/test.h"
  26 #include "winuser.h"
  27 #include "initguid.h"
  28 #include "shlwapi.h"
  29 #include "shlguid.h"
  30 #include "comcat.h"
  31 #include "msctf.h"
  32 #include "olectl.h"
  33
  34 static ITfInputProcessorProfiles* g_ipp;
  35 static LANGID gLangid;
  36 static ITfCategoryMgr * g_cm = NULL;
  37 static ITfThreadMgr* g_tm = NULL;
  38 static ITfDocumentMgr *g_dm = NULL;
  39 static TfClientId cid = 0;
  40 static TfClientId tid = 0;
  41
  42 static ITextStoreACPSink *ACPSink;
  43
  44 #define SINK_UNEXPECTED 0
  45 #define SINK_EXPECTED 1
  46 #define SINK_FIRED 2
  47 #define SINK_IGNORE 3
  48 #define SINK_OPTIONAL 4
  49 #define SINK_SAVE 5
  50
  51 #define SINK_ACTION_MASK 0xff
  52 #define SINK_OPTION_MASK 0xff00
  53 #define SINK_EXPECTED_COUNT_MASK 0xff0000
  54
  55 #define SINK_OPTION_TODO      0x0100
  56
  57 #define FOCUS_IGNORE    (ITfDocumentMgr*)0xffffffff
  58 #define FOCUS_SAVE      (ITfDocumentMgr*)0xfffffffe
  59
  60 static BOOL test_ShouldActivate = FALSE;
  61 static BOOL test_ShouldDeactivate = FALSE;
  62
  63 static DWORD tmSinkCookie;
  64 static DWORD tmSinkRefCount;
  65 static DWORD documentStatus;
  66 static ITfDocumentMgr *test_CurrentFocus = NULL;
  67 static ITfDocumentMgr *test_PrevFocus = NULL;
  68 static ITfDocumentMgr *test_LastCurrentFocus = FOCUS_SAVE;
  69 static ITfDocumentMgr *test_FirstPrevFocus = FOCUS_SAVE;
  70 static INT  test_OnSetFocus = SINK_UNEXPECTED;
  71 static INT  test_OnInitDocumentMgr = SINK_UNEXPECTED;
  72 static INT  test_OnPushContext = SINK_UNEXPECTED;
  73 static INT  test_OnPopContext = SINK_UNEXPECTED;
  74 static INT  test_KEV_OnSetFocus = SINK_UNEXPECTED;
  75 static INT  test_ACP_AdviseSink = SINK_UNEXPECTED;
  76 static INT  test_ACP_GetStatus = SINK_UNEXPECTED;
  77 static INT  test_ACP_RequestLock = SINK_UNEXPECTED;
  78 static INT  test_ACP_GetEndACP = SINK_UNEXPECTED;
  79 static INT  test_ACP_GetSelection = SINK_UNEXPECTED;
  80 static INT  test_DoEditSession = SINK_UNEXPECTED;
  81 static INT  test_ACP_InsertTextAtSelection = SINK_UNEXPECTED;
  82 static INT  test_ACP_SetSelection = SINK_UNEXPECTED;
  83 static INT  test_OnEndEdit = SINK_UNEXPECTED;
  84
  85
  86 static inline int expected_count(int *sink)
  87 {
  88     return (*sink & SINK_EXPECTED_COUNT_MASK)>>16;
  89 }
  90
  91 static inline void _sink_fire_ok(INT *sink, const CHAR* name)
  92 {
  93     int count;
  94     int todo = *sink & SINK_OPTION_TODO;
  95     int action = *sink & SINK_ACTION_MASK;
  96
  97     if (winetest_interactive)
  98         winetest_trace("firing %s\n",name);
  99
 100     switch (action)
 101     {
 102         case SINK_OPTIONAL:
 103         case SINK_EXPECTED:
 104             count = expected_count(sink);
 105             if (count > 1)
 106             {
 107                 count --;
 108                 *sink = (*sink & ~SINK_EXPECTED_COUNT_MASK) + (count << 16);
 109                 return;
 110             }
 111             break;
 112         case SINK_IGNORE:
 113             winetest_trace("Ignoring %s\n",name);
 114             return;
 115         case SINK_SAVE:
 116             count = expected_count(sink) + 1;
 117             *sink = (*sink & ~SINK_EXPECTED_COUNT_MASK) + (count << 16);
 118             return;
 119         default:
 120             if (todo)
 121                 todo_wine winetest_ok(0, "Unexpected %s sink\n",name);
 122             else
 123                 winetest_ok(0, "Unexpected %s sink\n",name);
 124     }
 125     *sink = SINK_FIRED;
 126 }
 127
 128 #define sink_fire_ok(a,b) (winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _sink_fire_ok(a,b)
 129
 130 static inline void _sink_check_ok(INT *sink, const CHAR* name)
 131 {
 132     int action = *sink & SINK_ACTION_MASK;
 133     int todo = *sink & SINK_OPTION_TODO;
 134     int count = expected_count(sink);
 135
 136     switch (action)
 137     {
 138         case SINK_OPTIONAL:
 139             if (winetest_interactive)
 140                 winetest_trace("optional sink %s not fired\n",name);
 141         case SINK_FIRED:
 142             break;
 143         case SINK_IGNORE:
 144             return;
 145         case SINK_SAVE:
 146             if (count == 0 && winetest_interactive)
 147                 winetest_trace("optional sink %s not fired\n",name);
 148             break;
 149         default:
 150             if (todo)
 151                 todo_wine winetest_ok(0, "%s not fired as expected, in state %x\n",name,*sink);
 152             else
 153                 winetest_ok(0, "%s not fired as expected, in state %x\n",name,*sink);
 154     }
 155     *sink = SINK_UNEXPECTED;
 156 }
 157
 158 #define sink_check_ok(a,b) (winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _sink_check_ok(a,b)
 159
 160 static inline void _sink_check_saved(INT *sink, ITfDocumentMgr *PrevFocus, ITfDocumentMgr *CurrentFocus, const CHAR* name)
 161 {
 162     int count = expected_count(sink);
 163     _sink_check_ok(sink, name);
 164     if (PrevFocus != FOCUS_IGNORE && count != 0)
 165         winetest_ok(PrevFocus == test_FirstPrevFocus, "%s expected prev focus %p got %p\n", name, PrevFocus, test_FirstPrevFocus);
 166     if (CurrentFocus != FOCUS_IGNORE && count != 0)
 167         winetest_ok(CurrentFocus == test_LastCurrentFocus, "%s expected current focus %p got %p\n", name, CurrentFocus, test_LastCurrentFocus);
 168     test_FirstPrevFocus = FOCUS_SAVE;
 169     test_LastCurrentFocus = FOCUS_SAVE;
 170 }
 171
 172 #define sink_check_saved(s,p,c,n) (winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _sink_check_saved(s,p,c,n)
 173
 174 /**********************************************************************
 175  * ITextStoreACP
 176  **********************************************************************/
 177 typedef struct tagTextStoreACP
 178 {
 179     ITextStoreACP ITextStoreACP_iface;
 180     LONG refCount;
 181
 182 } TextStoreACP;
 183
 184 static inline TextStoreACP *impl_from_ITextStoreACP(ITextStoreACP *iface)
 185 {
 186     return CONTAINING_RECORD(iface, TextStoreACP, ITextStoreACP_iface);
 187 }
 188
 189 static void TextStoreACP_Destructor(TextStoreACP *This)
 190 {
 191     HeapFree(GetProcessHeap(),0,This);
 192 }
 193
 194 static HRESULT WINAPI TextStoreACP_QueryInterface(ITextStoreACP *iface, REFIID iid, LPVOID *ppvOut)
 195 {
 196     TextStoreACP *This = impl_from_ITextStoreACP(iface);
 197     *ppvOut = NULL;
 198
 199     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITextStoreACP))
 200     {
 201         *ppvOut = This;
 202     }
 203
 204     if (*ppvOut)
 205     {
 206         ITextStoreACP_AddRef(iface);
 207         return S_OK;
 208     }
 209
 210     return E_NOINTERFACE;
 211 }
 212
 213 static ULONG WINAPI TextStoreACP_AddRef(ITextStoreACP *iface)
 214 {
 215     TextStoreACP *This = impl_from_ITextStoreACP(iface);
 216     return InterlockedIncrement(&This->refCount);
 217 }
 218
 219 static ULONG WINAPI TextStoreACP_Release(ITextStoreACP *iface)
 220 {
 221     TextStoreACP *This = impl_from_ITextStoreACP(iface);
 222     ULONG ret;
 223
 224     ret = InterlockedDecrement(&This->refCount);
 225     if (ret == 0)
 226         TextStoreACP_Destructor(This);
 227     return ret;
 228 }
 229
 230 static HRESULT WINAPI TextStoreACP_AdviseSink(ITextStoreACP *iface,
 231     REFIID riid, IUnknown *punk, DWORD dwMask)
 232 {
 233     HRESULT hr;
 234
 235     sink_fire_ok(&test_ACP_AdviseSink,"TextStoreACP_AdviseSink");
 236
 237     hr = IUnknown_QueryInterface(punk, &IID_ITextStoreACPSink,(LPVOID*)(&ACPSink));
 238     ok(SUCCEEDED(hr),"Unable to QueryInterface on sink\n");
 239     return S_OK;
 240 }
 241
 242 static HRESULT WINAPI TextStoreACP_UnadviseSink(ITextStoreACP *iface,
 243     IUnknown *punk)
 244 {
 245     trace("\n");
 246     return S_OK;
 247 }
 248
 249 static HRESULT WINAPI TextStoreACP_RequestLock(ITextStoreACP *iface,
 250     DWORD dwLockFlags, HRESULT *phrSession)
 251 {
 252     sink_fire_ok(&test_ACP_RequestLock,"TextStoreACP_RequestLock");
 253     *phrSession = ITextStoreACPSink_OnLockGranted(ACPSink, dwLockFlags);
 254     return S_OK;
 255 }
 256 static HRESULT WINAPI TextStoreACP_GetStatus(ITextStoreACP *iface,
 257     TS_STATUS *pdcs)
 258 {
 259     sink_fire_ok(&test_ACP_GetStatus,"TextStoreACP_GetStatus");
 260     pdcs->dwDynamicFlags = documentStatus;
 261     return S_OK;
 262 }
 263 static HRESULT WINAPI TextStoreACP_QueryInsert(ITextStoreACP *iface,
 264     LONG acpTestStart, LONG acpTestEnd, ULONG cch, LONG *pacpResultStart,
 265     LONG *pacpResultEnd)
 266 {
 267     trace("\n");
 268     return S_OK;
 269 }
 270 static HRESULT WINAPI TextStoreACP_GetSelection(ITextStoreACP *iface,
 271     ULONG ulIndex, ULONG ulCount, TS_SELECTION_ACP *pSelection, ULONG *pcFetched)
 272 {
 273     sink_fire_ok(&test_ACP_GetSelection,"TextStoreACP_GetSelection");
 274
 275     pSelection->acpStart = 10;
 276     pSelection->acpEnd = 20;
 277     pSelection->style.fInterimChar = 0;
 278     pSelection->style.ase = TS_AE_NONE;
 279     *pcFetched = 1;
 280
 281     return S_OK;
 282 }
 283 static HRESULT WINAPI TextStoreACP_SetSelection(ITextStoreACP *iface,
 284     ULONG ulCount, const TS_SELECTION_ACP *pSelection)
 285 {
 286     sink_fire_ok(&test_ACP_SetSelection,"TextStoreACP_SetSelection");
 287     return S_OK;
 288 }
 289 static HRESULT WINAPI TextStoreACP_GetText(ITextStoreACP *iface,
 290     LONG acpStart, LONG acpEnd, WCHAR *pchPlain, ULONG cchPlainReq,
 291     ULONG *pcchPlainRet, TS_RUNINFO *prgRunInfo, ULONG cRunInfoReq,
 292     ULONG *pcRunInfoRet, LONG *pacpNext)
 293 {
 294     trace("\n");
 295     return S_OK;
 296 }
 297 static HRESULT WINAPI TextStoreACP_SetText(ITextStoreACP *iface,
 298     DWORD dwFlags, LONG acpStart, LONG acpEnd, const WCHAR *pchText,
 299     ULONG cch, TS_TEXTCHANGE *pChange)
 300 {
 301     trace("\n");
 302     return S_OK;
 303 }
 304 static HRESULT WINAPI TextStoreACP_GetFormattedText(ITextStoreACP *iface,
 305     LONG acpStart, LONG acpEnd, IDataObject **ppDataObject)
 306 {
 307     trace("\n");
 308     return S_OK;
 309 }
 310 static HRESULT WINAPI TextStoreACP_GetEmbedded(ITextStoreACP *iface,
 311     LONG acpPos, REFGUID rguidService, REFIID riid, IUnknown **ppunk)
 312 {
 313     trace("\n");
 314     return S_OK;
 315 }
 316 static HRESULT WINAPI TextStoreACP_QueryInsertEmbedded(ITextStoreACP *iface,
 317     const GUID *pguidService, const FORMATETC *pFormatEtc, BOOL *pfInsertable)
 318 {
 319     trace("\n");
 320     return S_OK;
 321 }
 322 static HRESULT WINAPI TextStoreACP_InsertEmbedded(ITextStoreACP *iface,
 323     DWORD dwFlags, LONG acpStart, LONG acpEnd, IDataObject *pDataObject,
 324     TS_TEXTCHANGE *pChange)
 325 {
 326     trace("\n");
 327     return S_OK;
 328 }
 329 static HRESULT WINAPI TextStoreACP_InsertTextAtSelection(ITextStoreACP *iface,
 330     DWORD dwFlags, const WCHAR *pchText, ULONG cch, LONG *pacpStart,
 331     LONG *pacpEnd, TS_TEXTCHANGE *pChange)
 332 {
 333     sink_fire_ok(&test_ACP_InsertTextAtSelection,"TextStoreACP_InsertTextAtSelection");
 334     return S_OK;
 335 }
 336 static HRESULT WINAPI TextStoreACP_InsertEmbeddedAtSelection(ITextStoreACP *iface,
 337     DWORD dwFlags, IDataObject *pDataObject, LONG *pacpStart, LONG *pacpEnd,
 338     TS_TEXTCHANGE *pChange)
 339 {
 340     trace("\n");
 341     return S_OK;
 342 }
 343 static HRESULT WINAPI TextStoreACP_RequestSupportedAttrs(ITextStoreACP *iface,
 344     DWORD dwFlags, ULONG cFilterAttrs, const TS_ATTRID *paFilterAttrs)
 345 {
 346     trace("\n");
 347     return S_OK;
 348 }
 349 static HRESULT WINAPI TextStoreACP_RequestAttrsAtPosition(ITextStoreACP *iface,
 350     LONG acpPos, ULONG cFilterAttrs, const TS_ATTRID *paFilterAttrs,
 351     DWORD dwFlags)
 352 {
 353     trace("\n");
 354     return S_OK;
 355 }
 356 static HRESULT WINAPI TextStoreACP_RequestAttrsTransitioningAtPosition(ITextStoreACP *iface,
 357     LONG acpPos, ULONG cFilterAttrs, const TS_ATTRID *paFilterAttrs,
 358     DWORD dwFlags)
 359 {
 360     trace("\n");
 361     return S_OK;
 362 }
 363 static HRESULT WINAPI TextStoreACP_FindNextAttrTransition(ITextStoreACP *iface,
 364     LONG acpStart, LONG acpHalt, ULONG cFilterAttrs, const TS_ATTRID *paFilterAttrs,
 365     DWORD dwFlags, LONG *pacpNext, BOOL *pfFound, LONG *plFoundOffset)
 366 {
 367     trace("\n");
 368     return S_OK;
 369 }
 370 static HRESULT WINAPI TextStoreACP_RetrieveRequestedAttrs(ITextStoreACP *iface,
 371     ULONG ulCount, TS_ATTRVAL *paAttrVals, ULONG *pcFetched)
 372 {
 373     trace("\n");
 374     return S_OK;
 375 }
 376 static HRESULT WINAPI TextStoreACP_GetEndACP(ITextStoreACP *iface,
 377     LONG *pacp)
 378 {
 379     sink_fire_ok(&test_ACP_GetEndACP,"TextStoreACP_GetEndACP");
 380     return S_OK;
 381 }
 382 static HRESULT WINAPI TextStoreACP_GetActiveView(ITextStoreACP *iface,
 383     TsViewCookie *pvcView)
 384 {
 385     trace("\n");
 386     return S_OK;
 387 }
 388 static HRESULT WINAPI TextStoreACP_GetACPFromPoint(ITextStoreACP *iface,
 389     TsViewCookie vcView, const POINT *ptScreen, DWORD dwFlags,
 390     LONG *pacp)
 391 {
 392     trace("\n");
 393     return S_OK;
 394 }
 395 static HRESULT WINAPI TextStoreACP_GetTextExt(ITextStoreACP *iface,
 396     TsViewCookie vcView, LONG acpStart, LONG acpEnd, RECT *prc,
 397     BOOL *pfClipped)
 398 {
 399     trace("\n");
 400     return S_OK;
 401 }
 402 static HRESULT WINAPI TextStoreACP_GetScreenExt(ITextStoreACP *iface,
 403     TsViewCookie vcView, RECT *prc)
 404 {
 405     trace("\n");
 406     return S_OK;
 407 }
 408 static HRESULT WINAPI TextStoreACP_GetWnd(ITextStoreACP *iface,
 409     TsViewCookie vcView, HWND *phwnd)
 410 {
 411     trace("\n");
 412     return S_OK;
 413 }
 414
 415 static const ITextStoreACPVtbl TextStoreACP_TextStoreACPVtbl =
 416 {
 417     TextStoreACP_QueryInterface,
 418     TextStoreACP_AddRef,
 419     TextStoreACP_Release,
 420
 421     TextStoreACP_AdviseSink,
 422     TextStoreACP_UnadviseSink,
 423     TextStoreACP_RequestLock,
 424     TextStoreACP_GetStatus,
 425     TextStoreACP_QueryInsert,
 426     TextStoreACP_GetSelection,
 427     TextStoreACP_SetSelection,
 428     TextStoreACP_GetText,
 429     TextStoreACP_SetText,
 430     TextStoreACP_GetFormattedText,
 431     TextStoreACP_GetEmbedded,
 432     TextStoreACP_QueryInsertEmbedded,
 433     TextStoreACP_InsertEmbedded,
 434     TextStoreACP_InsertTextAtSelection,
 435     TextStoreACP_InsertEmbeddedAtSelection,
 436     TextStoreACP_RequestSupportedAttrs,
 437     TextStoreACP_RequestAttrsAtPosition,
 438     TextStoreACP_RequestAttrsTransitioningAtPosition,
 439     TextStoreACP_FindNextAttrTransition,
 440     TextStoreACP_RetrieveRequestedAttrs,
 441     TextStoreACP_GetEndACP,
 442     TextStoreACP_GetActiveView,
 443     TextStoreACP_GetACPFromPoint,
 444     TextStoreACP_GetTextExt,
 445     TextStoreACP_GetScreenExt,
 446     TextStoreACP_GetWnd
 447 };
 448
 449 static HRESULT TextStoreACP_Constructor(IUnknown **ppOut)
 450 {
 451     TextStoreACP *This;
 452
 453     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(TextStoreACP));
 454     if (This == NULL)
 455         return E_OUTOFMEMORY;
 456
 457     This->ITextStoreACP_iface.lpVtbl = &TextStoreACP_TextStoreACPVtbl;
 458     This->refCount = 1;
 459
 460     *ppOut = (IUnknown *)This;
 461     return S_OK;
 462 }
 463
 464 /**********************************************************************
 465  * ITfThreadMgrEventSink
 466  **********************************************************************/
 467 typedef struct tagThreadMgrEventSink
 468 {
 469     ITfThreadMgrEventSink ITfThreadMgrEventSink_iface;
 470     LONG refCount;
 471 } ThreadMgrEventSink;
 472
 473 static inline ThreadMgrEventSink *impl_from_ITfThreadMgrEventSink(ITfThreadMgrEventSink *iface)
 474 {
 475     return CONTAINING_RECORD(iface, ThreadMgrEventSink, ITfThreadMgrEventSink_iface);
 476 }
 477
 478 static void ThreadMgrEventSink_Destructor(ThreadMgrEventSink *This)
 479 {
 480     HeapFree(GetProcessHeap(),0,This);
 481 }
 482
 483 static HRESULT WINAPI ThreadMgrEventSink_QueryInterface(ITfThreadMgrEventSink *iface, REFIID iid, LPVOID *ppvOut)
 484 {
 485     ThreadMgrEventSink *This = impl_from_ITfThreadMgrEventSink(iface);
 486     *ppvOut = NULL;
 487
 488     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfThreadMgrEventSink))
 489     {
 490         *ppvOut = This;
 491     }
 492
 493     if (*ppvOut)
 494     {
 495         ITfThreadMgrEventSink_AddRef(iface);
 496         return S_OK;
 497     }
 498
 499     return E_NOINTERFACE;
 500 }
 501
 502 static ULONG WINAPI ThreadMgrEventSink_AddRef(ITfThreadMgrEventSink *iface)
 503 {
 504     ThreadMgrEventSink *This = impl_from_ITfThreadMgrEventSink(iface);
 505     ok (tmSinkRefCount == This->refCount,"ThreadMgrEventSink refcount off %i vs %i\n",This->refCount,tmSinkRefCount);
 506     return InterlockedIncrement(&This->refCount);
 507 }
 508
 509 static ULONG WINAPI ThreadMgrEventSink_Release(ITfThreadMgrEventSink *iface)
 510 {
 511     ThreadMgrEventSink *This = impl_from_ITfThreadMgrEventSink(iface);
 512     ULONG ret;
 513
 514     ok (tmSinkRefCount == This->refCount,"ThreadMgrEventSink refcount off %i vs %i\n",This->refCount,tmSinkRefCount);
 515     ret = InterlockedDecrement(&This->refCount);
 516     if (ret == 0)
 517         ThreadMgrEventSink_Destructor(This);
 518     return ret;
 519 }
 520
 521 static HRESULT WINAPI ThreadMgrEventSink_OnInitDocumentMgr(ITfThreadMgrEventSink *iface,
 522 ITfDocumentMgr *pdim)
 523 {
 524     sink_fire_ok(&test_OnInitDocumentMgr,"ThreadMgrEventSink_OnInitDocumentMgr");
 525     return S_OK;
 526 }
 527
 528 static HRESULT WINAPI ThreadMgrEventSink_OnUninitDocumentMgr(ITfThreadMgrEventSink *iface,
 529 ITfDocumentMgr *pdim)
 530 {
 531     trace("\n");
 532     return S_OK;
 533 }
 534
 535 static HRESULT WINAPI ThreadMgrEventSink_OnSetFocus(ITfThreadMgrEventSink *iface,
 536 ITfDocumentMgr *pdimFocus, ITfDocumentMgr *pdimPrevFocus)
 537 {
 538     sink_fire_ok(&test_OnSetFocus,"ThreadMgrEventSink_OnSetFocus");
 539     if (test_CurrentFocus == FOCUS_SAVE)
 540         test_LastCurrentFocus = pdimFocus;
 541     else if (test_CurrentFocus != FOCUS_IGNORE)
 542         ok(pdimFocus == test_CurrentFocus,"Sink reports wrong focus\n");
 543     if (test_PrevFocus == FOCUS_SAVE)
 544     {
 545         if (test_FirstPrevFocus == FOCUS_SAVE)
 546             test_FirstPrevFocus = pdimPrevFocus;
 547     }
 548     else if (test_PrevFocus != FOCUS_IGNORE)
 549         ok(pdimPrevFocus == test_PrevFocus,"Sink reports wrong previous focus\n");
 550     return S_OK;
 551 }
 552
 553 static HRESULT WINAPI ThreadMgrEventSink_OnPushContext(ITfThreadMgrEventSink *iface,
 554 ITfContext *pic)
 555 {
 556     HRESULT hr;
 557     ITfDocumentMgr *docmgr;
 558     ITfContext *test;
 559
 560     hr = ITfContext_GetDocumentMgr(pic,&docmgr);
 561     ok(SUCCEEDED(hr),"GetDocumentMgr failed\n");
 562     test = (ITfContext*)0xdeadbeef;
 563     ITfDocumentMgr_Release(docmgr);
 564     hr = ITfDocumentMgr_GetTop(docmgr,&test);
 565     ok(SUCCEEDED(hr),"GetTop failed\n");
 566     ok(test == pic, "Wrong context is on top\n");
 567     if (test)
 568         ITfContext_Release(test);
 569
 570     sink_fire_ok(&test_OnPushContext,"ThreadMgrEventSink_OnPushContext");
 571     return S_OK;
 572 }
 573
 574 static HRESULT WINAPI ThreadMgrEventSink_OnPopContext(ITfThreadMgrEventSink *iface,
 575 ITfContext *pic)
 576 {
 577     HRESULT hr;
 578     ITfDocumentMgr *docmgr;
 579     ITfContext *test;
 580
 581     hr = ITfContext_GetDocumentMgr(pic,&docmgr);
 582     ok(SUCCEEDED(hr),"GetDocumentMgr failed\n");
 583     ITfDocumentMgr_Release(docmgr);
 584     test = (ITfContext*)0xdeadbeef;
 585     hr = ITfDocumentMgr_GetTop(docmgr,&test);
 586     ok(SUCCEEDED(hr),"GetTop failed\n");
 587     ok(test == pic, "Wrong context is on top\n");
 588     if (test)
 589         ITfContext_Release(test);
 590
 591     sink_fire_ok(&test_OnPopContext,"ThreadMgrEventSink_OnPopContext");
 592     return S_OK;
 593 }
 594
 595 static const ITfThreadMgrEventSinkVtbl ThreadMgrEventSink_ThreadMgrEventSinkVtbl =
 596 {
 597     ThreadMgrEventSink_QueryInterface,
 598     ThreadMgrEventSink_AddRef,
 599     ThreadMgrEventSink_Release,
 600
 601     ThreadMgrEventSink_OnInitDocumentMgr,
 602     ThreadMgrEventSink_OnUninitDocumentMgr,
 603     ThreadMgrEventSink_OnSetFocus,
 604     ThreadMgrEventSink_OnPushContext,
 605     ThreadMgrEventSink_OnPopContext
 606 };
 607
 608 static HRESULT ThreadMgrEventSink_Constructor(IUnknown **ppOut)
 609 {
 610     ThreadMgrEventSink *This;
 611
 612     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ThreadMgrEventSink));
 613     if (This == NULL)
 614         return E_OUTOFMEMORY;
 615
 616     This->ITfThreadMgrEventSink_iface.lpVtbl = &ThreadMgrEventSink_ThreadMgrEventSinkVtbl;
 617     This->refCount = 1;
 618
 619     *ppOut = (IUnknown *)This;
 620     return S_OK;
 621 }
 622
 623
 624 /********************************************************************************************
 625  * Stub text service for testing
 626  ********************************************************************************************/
 627
 628 static LONG TS_refCount;
 629 static IClassFactory *cf;
 630 static DWORD regid;
 631
 632 typedef HRESULT (*LPFNCONSTRUCTOR)(IUnknown *pUnkOuter, IUnknown **ppvOut);
 633
 634 typedef struct tagClassFactory
 635 {
 636     IClassFactory IClassFactory_iface;
 637     LONG   ref;
 638     LPFNCONSTRUCTOR ctor;
 639 } ClassFactory;
 640
 641 static inline ClassFactory *impl_from_IClassFactory(IClassFactory *iface)
 642 {
 643     return CONTAINING_RECORD(iface, ClassFactory, IClassFactory_iface);
 644 }
 645
 646 typedef struct tagTextService
 647 {
 648     ITfTextInputProcessor ITfTextInputProcessor_iface;
 649     LONG refCount;
 650 } TextService;
 651
 652 static inline TextService *impl_from_ITfTextInputProcessor(ITfTextInputProcessor *iface)
 653 {
 654     return CONTAINING_RECORD(iface, TextService, ITfTextInputProcessor_iface);
 655 }
 656
 657 static void ClassFactory_Destructor(ClassFactory *This)
 658 {
 659     HeapFree(GetProcessHeap(),0,This);
 660     TS_refCount--;
 661 }
 662
 663 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, LPVOID *ppvOut)
 664 {
 665     *ppvOut = NULL;
 666     if (IsEqualIID(riid, &IID_IClassFactory) || IsEqualIID(riid, &IID_IUnknown))
 667     {
 668         IClassFactory_AddRef(iface);
 669         *ppvOut = iface;
 670         return S_OK;
 671     }
 672
 673     return E_NOINTERFACE;
 674 }
 675
 676 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 677 {
 678     ClassFactory *This = impl_from_IClassFactory(iface);
 679     return InterlockedIncrement(&This->ref);
 680 }
 681
 682 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 683 {
 684     ClassFactory *This = impl_from_IClassFactory(iface);
 685     ULONG ret = InterlockedDecrement(&This->ref);
 686
 687     if (ret == 0)
 688         ClassFactory_Destructor(This);
 689     return ret;
 690 }
 691
 692 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *punkOuter, REFIID iid, LPVOID *ppvOut)
 693 {
 694     ClassFactory *This = impl_from_IClassFactory(iface);
 695     HRESULT ret;
 696     IUnknown *obj;
 697
 698     ret = This->ctor(punkOuter, &obj);
 699     if (FAILED(ret))
 700         return ret;
 701     ret = IUnknown_QueryInterface(obj, iid, ppvOut);
 702     IUnknown_Release(obj);
 703     return ret;
 704 }
 705
 706 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL fLock)
 707 {
 708     if(fLock)
 709         InterlockedIncrement(&TS_refCount);
 710     else
 711         InterlockedDecrement(&TS_refCount);
 712
 713     return S_OK;
 714 }
 715
 716 static const IClassFactoryVtbl ClassFactoryVtbl = {
 717     /* IUnknown */
 718     ClassFactory_QueryInterface,
 719     ClassFactory_AddRef,
 720     ClassFactory_Release,
 721
 722     /* IClassFactory*/
 723     ClassFactory_CreateInstance,
 724     ClassFactory_LockServer
 725 };
 726
 727 static HRESULT ClassFactory_Constructor(LPFNCONSTRUCTOR ctor, LPVOID *ppvOut)
 728 {
 729     ClassFactory *This = HeapAlloc(GetProcessHeap(),0,sizeof(ClassFactory));
 730     This->IClassFactory_iface.lpVtbl = &ClassFactoryVtbl;
 731     This->ref = 1;
 732     This->ctor = ctor;
 733     *ppvOut = (LPVOID)This;
 734     TS_refCount++;
 735     return S_OK;
 736 }
 737
 738 static void TextService_Destructor(TextService *This)
 739 {
 740     HeapFree(GetProcessHeap(),0,This);
 741 }
 742
 743 static HRESULT WINAPI TextService_QueryInterface(ITfTextInputProcessor *iface, REFIID iid, LPVOID *ppvOut)
 744 {
 745     TextService *This = impl_from_ITfTextInputProcessor(iface);
 746     *ppvOut = NULL;
 747
 748     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfTextInputProcessor))
 749     {
 750         *ppvOut = This;
 751     }
 752
 753     if (*ppvOut)
 754     {
 755         ITfTextInputProcessor_AddRef(iface);
 756         return S_OK;
 757     }
 758
 759     return E_NOINTERFACE;
 760 }
 761
 762 static ULONG WINAPI TextService_AddRef(ITfTextInputProcessor *iface)
 763 {
 764     TextService *This = impl_from_ITfTextInputProcessor(iface);
 765     return InterlockedIncrement(&This->refCount);
 766 }
 767
 768 static ULONG WINAPI TextService_Release(ITfTextInputProcessor *iface)
 769 {
 770     TextService *This = impl_from_ITfTextInputProcessor(iface);
 771     ULONG ret;
 772
 773     ret = InterlockedDecrement(&This->refCount);
 774     if (ret == 0)
 775         TextService_Destructor(This);
 776     return ret;
 777 }
 778
 779 static HRESULT WINAPI TextService_Activate(ITfTextInputProcessor *iface,
 780         ITfThreadMgr *ptim, TfClientId id)
 781 {
 782     trace("TextService_Activate\n");
 783     ok(test_ShouldActivate,"Activation came unexpectedly\n");
 784     tid = id;
 785     return S_OK;
 786 }
 787
 788 static HRESULT WINAPI TextService_Deactivate(ITfTextInputProcessor *iface)
 789 {
 790     trace("TextService_Deactivate\n");
 791     ok(test_ShouldDeactivate,"Deactivation came unexpectedly\n");
 792     return S_OK;
 793 }
 794
 795 static const ITfTextInputProcessorVtbl TextService_TextInputProcessorVtbl=
 796 {
 797     TextService_QueryInterface,
 798     TextService_AddRef,
 799     TextService_Release,
 800
 801     TextService_Activate,
 802     TextService_Deactivate
 803 };
 804
 805 static HRESULT TextService_Constructor(IUnknown *pUnkOuter, IUnknown **ppOut)
 806 {
 807     TextService *This;
 808     if (pUnkOuter)
 809         return CLASS_E_NOAGGREGATION;
 810
 811     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(TextService));
 812     if (This == NULL)
 813         return E_OUTOFMEMORY;
 814
 815     This->ITfTextInputProcessor_iface.lpVtbl = &TextService_TextInputProcessorVtbl;
 816     This->refCount = 1;
 817
 818     *ppOut = (IUnknown *)This;
 819     return S_OK;
 820 }
 821
 822 static HRESULT RegisterTextService(REFCLSID rclsid)
 823 {
 824     ClassFactory_Constructor( TextService_Constructor ,(LPVOID*)&cf);
 825     return CoRegisterClassObject(rclsid, (IUnknown*) cf, CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
 826 }
 827
 828 static HRESULT UnregisterTextService(void)
 829 {
 830     return CoRevokeClassObject(regid);
 831 }
 832
 833 /*
 834  * The tests
 835  */
 836
 837 DEFINE_GUID(CLSID_FakeService, 0xEDE1A7AD,0x66DE,0x47E0,0xB6,0x20,0x3E,0x92,0xF8,0x24,0x6B,0xF3);
 838 DEFINE_GUID(CLSID_TF_InputProcessorProfiles, 0x33c53a50,0xf456,0x4884,0xb0,0x49,0x85,0xfd,0x64,0x3e,0xcf,0xed);
 839 DEFINE_GUID(CLSID_TF_CategoryMgr,         0xA4B544A1,0x438D,0x4B41,0x93,0x25,0x86,0x95,0x23,0xE2,0xD6,0xC7);
 840 DEFINE_GUID(GUID_TFCAT_TIP_KEYBOARD,     0x34745c63,0xb2f0,0x4784,0x8b,0x67,0x5e,0x12,0xc8,0x70,0x1a,0x31);
 841 DEFINE_GUID(GUID_TFCAT_TIP_SPEECH,       0xB5A73CD1,0x8355,0x426B,0xA1,0x61,0x25,0x98,0x08,0xF2,0x6B,0x14);
 842 DEFINE_GUID(GUID_TFCAT_TIP_HANDWRITING,  0x246ecb87,0xc2f2,0x4abe,0x90,0x5b,0xc8,0xb3,0x8a,0xdd,0x2c,0x43);
 843 DEFINE_GUID (GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER,  0x046B8C80,0x1647,0x40F7,0x9B,0x21,0xB9,0x3B,0x81,0xAA,0xBC,0x1B);
 844 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
 845 DEFINE_GUID(CLSID_TF_ThreadMgr,           0x529a9e6b,0x6587,0x4f23,0xab,0x9e,0x9c,0x7d,0x68,0x3e,0x3c,0x50);
 846 DEFINE_GUID(CLSID_PreservedKey,           0xA0ED8E55,0xCD3B,0x4274,0xB2,0x95,0xF6,0xC9,0xBA,0x2B,0x84,0x72);
 847 DEFINE_GUID(GUID_COMPARTMENT_KEYBOARD_DISABLED,     0x71a5b253,0x1951,0x466b,0x9f,0xbc,0x9c,0x88,0x08,0xfa,0x84,0xf2);
 848 DEFINE_GUID(GUID_COMPARTMENT_KEYBOARD_OPENCLOSE,    0x58273aad,0x01bb,0x4164,0x95,0xc6,0x75,0x5b,0xa0,0xb5,0x16,0x2d);
 849 DEFINE_GUID(GUID_COMPARTMENT_HANDWRITING_OPENCLOSE, 0xf9ae2c6b,0x1866,0x4361,0xaf,0x72,0x7a,0xa3,0x09,0x48,0x89,0x0e);
 850 DEFINE_GUID(GUID_COMPARTMENT_SPEECH_DISABLED,       0x56c5c607,0x0703,0x4e59,0x8e,0x52,0xcb,0xc8,0x4e,0x8b,0xbe,0x35);
 851 DEFINE_GUID(GUID_COMPARTMENT_SPEECH_OPENCLOSE,      0x544d6a63,0xe2e8,0x4752,0xbb,0xd1,0x00,0x09,0x60,0xbc,0xa0,0x83);
 852 DEFINE_GUID(GUID_COMPARTMENT_SPEECH_GLOBALSTATE,    0x2a54fe8e,0x0d08,0x460c,0xa7,0x5d,0x87,0x03,0x5f,0xf4,0x36,0xc5);
 853 DEFINE_GUID(GUID_COMPARTMENT_PERSISTMENUENABLED,    0x575f3783,0x70c8,0x47c8,0xae,0x5d,0x91,0xa0,0x1a,0x1f,0x75,0x92);
 854 DEFINE_GUID(GUID_COMPARTMENT_EMPTYCONTEXT,          0xd7487dbf,0x804e,0x41c5,0x89,0x4d,0xad,0x96,0xfd,0x4e,0xea,0x13);
 855 DEFINE_GUID(GUID_COMPARTMENT_TIPUISTATUS,           0x148ca3ec,0x0366,0x401c,0x8d,0x75,0xed,0x97,0x8d,0x85,0xfb,0xc9);
 856
 857 static HRESULT initialize(void)
 858 {
 859     HRESULT hr;
 860     CoInitialize(NULL);
 861     hr = CoCreateInstance (&CLSID_TF_InputProcessorProfiles, NULL,
 862           CLSCTX_INPROC_SERVER, &IID_ITfInputProcessorProfiles, (void**)&g_ipp);
 863     if (SUCCEEDED(hr))
 864         hr = CoCreateInstance (&CLSID_TF_CategoryMgr, NULL,
 865           CLSCTX_INPROC_SERVER, &IID_ITfCategoryMgr, (void**)&g_cm);
 866     if (SUCCEEDED(hr))
 867         hr = CoCreateInstance (&CLSID_TF_ThreadMgr, NULL,
 868           CLSCTX_INPROC_SERVER, &IID_ITfThreadMgr, (void**)&g_tm);
 869     return hr;
 870 }
 871
 872 static void cleanup(void)
 873 {
 874     if (g_ipp)
 875         ITfInputProcessorProfiles_Release(g_ipp);
 876     if (g_cm)
 877         ITfCategoryMgr_Release(g_cm);
 878     if (g_tm)
 879         ITfThreadMgr_Release(g_tm);
 880     CoUninitialize();
 881 }
 882
 883 static void test_Register(void)
 884 {
 885     HRESULT hr;
 886
 887     static const WCHAR szDesc[] = {'F','a','k','e',' ','W','i','n','e',' ','S','e','r','v','i','c','e',0};
 888     static const WCHAR szFile[] = {'F','a','k','e',' ','W','i','n','e',' ','S','e','r','v','i','c','e',' ','F','i','l','e',0};
 889
 890     hr = ITfInputProcessorProfiles_GetCurrentLanguage(g_ipp,&gLangid);
 891     ok(SUCCEEDED(hr),"Unable to get current language id\n");
 892     trace("Current Language %x\n",gLangid);
 893
 894     hr = RegisterTextService(&CLSID_FakeService);
 895     ok(SUCCEEDED(hr),"Unable to register COM for TextService\n");
 896     hr = ITfInputProcessorProfiles_Register(g_ipp, &CLSID_FakeService);
 897     ok(SUCCEEDED(hr),"Unable to register text service(%x)\n",hr);
 898     hr = ITfInputProcessorProfiles_AddLanguageProfile(g_ipp, &CLSID_FakeService, gLangid, &CLSID_FakeService, szDesc, sizeof(szDesc)/sizeof(WCHAR), szFile, sizeof(szFile)/sizeof(WCHAR), 1);
 899     ok(SUCCEEDED(hr),"Unable to add Language Profile (%x)\n",hr);
 900 }
 901
 902 static void test_Unregister(void)
 903 {
 904     HRESULT hr;
 905     hr = ITfInputProcessorProfiles_Unregister(g_ipp, &CLSID_FakeService);
 906     ok(SUCCEEDED(hr),"Unable to unregister text service(%x)\n",hr);
 907     UnregisterTextService();
 908 }
 909
 910 static void test_EnumInputProcessorInfo(void)
 911 {
 912     IEnumGUID *ppEnum;
 913     BOOL found = FALSE;
 914
 915     if (SUCCEEDED(ITfInputProcessorProfiles_EnumInputProcessorInfo(g_ipp, &ppEnum)))
 916     {
 917         ULONG fetched;
 918         GUID g;
 919         while (IEnumGUID_Next(ppEnum, 1, &g, &fetched) == S_OK)
 920         {
 921             if(IsEqualGUID(&g,&CLSID_FakeService))
 922                 found = TRUE;
 923         }
 924     }
 925     ok(found,"Did not find registered text service\n");
 926 }
 927
 928 static void test_EnumLanguageProfiles(void)
 929 {
 930     BOOL found = FALSE;
 931     IEnumTfLanguageProfiles *ppEnum;
 932     if (SUCCEEDED(ITfInputProcessorProfiles_EnumLanguageProfiles(g_ipp,gLangid,&ppEnum)))
 933     {
 934         TF_LANGUAGEPROFILE profile;
 935         while (IEnumTfLanguageProfiles_Next(ppEnum,1,&profile,NULL)==S_OK)
 936         {
 937             if (IsEqualGUID(&profile.clsid,&CLSID_FakeService))
 938             {
 939                 found = TRUE;
 940                 ok(profile.langid == gLangid, "LangId Incorrect\n");
 941                 ok(IsEqualGUID(&profile.catid,&GUID_TFCAT_TIP_KEYBOARD) ||
 942                    broken(IsEqualGUID(&profile.catid,&GUID_NULL) /* Win8 */), "CatId Incorrect\n");
 943                 ok(IsEqualGUID(&profile.guidProfile,&CLSID_FakeService), "guidProfile Incorrect\n");
 944             }
 945         }
 946     }
 947     ok(found,"Registered text service not found\n");
 948 }
 949
 950 static void test_RegisterCategory(void)
 951 {
 952     HRESULT hr;
 953     hr = ITfCategoryMgr_RegisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_TIP_KEYBOARD, &CLSID_FakeService);
 954     ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterCategory failed\n");
 955     hr = ITfCategoryMgr_RegisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER, &CLSID_FakeService);
 956     ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterCategory failed\n");
 957 }
 958
 959 static void test_UnregisterCategory(void)
 960 {
 961     HRESULT hr;
 962     hr = ITfCategoryMgr_UnregisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_TIP_KEYBOARD, &CLSID_FakeService);
 963     ok(SUCCEEDED(hr),"ITfCategoryMgr_UnregisterCategory failed\n");
 964     hr = ITfCategoryMgr_UnregisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER, &CLSID_FakeService);
 965     ok(SUCCEEDED(hr),"ITfCategoryMgr_UnregisterCategory failed\n");
 966 }
 967
 968 static void test_FindClosestCategory(void)
 969 {
 970     GUID output;
 971     HRESULT hr;
 972     const GUID *list[3] = {&GUID_TFCAT_TIP_SPEECH, &GUID_TFCAT_TIP_KEYBOARD, &GUID_TFCAT_TIP_HANDWRITING};
 973
 974     hr = ITfCategoryMgr_FindClosestCategory(g_cm, &CLSID_FakeService, &output, NULL, 0);
 975     ok(SUCCEEDED(hr),"ITfCategoryMgr_FindClosestCategory failed (%x)\n",hr);
 976     ok(IsEqualGUID(&output,&GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER),"Wrong GUID\n");
 977
 978     hr = ITfCategoryMgr_FindClosestCategory(g_cm, &CLSID_FakeService, &output, list, 1);
 979     ok(SUCCEEDED(hr),"ITfCategoryMgr_FindClosestCategory failed (%x)\n",hr);
 980     ok(IsEqualGUID(&output,&GUID_NULL),"Wrong GUID\n");
 981
 982     hr = ITfCategoryMgr_FindClosestCategory(g_cm, &CLSID_FakeService, &output, list, 3);
 983     ok(SUCCEEDED(hr),"ITfCategoryMgr_FindClosestCategory failed (%x)\n",hr);
 984     ok(IsEqualGUID(&output,&GUID_TFCAT_TIP_KEYBOARD),"Wrong GUID\n");
 985 }
 986
 987 static void test_Enable(void)
 988 {
 989     HRESULT hr;
 990     BOOL enabled = FALSE;
 991
 992     hr = ITfInputProcessorProfiles_EnableLanguageProfile(g_ipp,&CLSID_FakeService, gLangid, &CLSID_FakeService, TRUE);
 993     ok(SUCCEEDED(hr),"Failed to enable text service\n");
 994     hr = ITfInputProcessorProfiles_IsEnabledLanguageProfile(g_ipp,&CLSID_FakeService, gLangid, &CLSID_FakeService, &enabled);
 995     ok(SUCCEEDED(hr),"Failed to get enabled state\n");
 996     ok(enabled == TRUE,"enabled state incorrect\n");
 997 }
 998
 999 static void test_Disable(void)
1000 {
1001     HRESULT hr;
1002
1003     trace("Disabling\n");
1004     hr = ITfInputProcessorProfiles_EnableLanguageProfile(g_ipp,&CLSID_FakeService, gLangid, &CLSID_FakeService, FALSE);
1005     ok(SUCCEEDED(hr),"Failed to disable text service\n");
1006 }
1007
1008 static void test_ThreadMgrAdviseSinks(void)
1009 {
1010     ITfSource *source = NULL;
1011     HRESULT hr;
1012     IUnknown *sink;
1013
1014     hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfSource, (LPVOID*)&source);
1015     ok(SUCCEEDED(hr),"Failed to get IID_ITfSource for ThreadMgr\n");
1016     if (!source)
1017         return;
1018
1019     hr = ThreadMgrEventSink_Constructor(&sink);
1020     ok(hr == S_OK, "got %08x\n", hr);
1021     if(FAILED(hr)) return;
1022
1023     tmSinkRefCount = 1;
1024     tmSinkCookie = 0;
1025     hr = ITfSource_AdviseSink(source,&IID_ITfThreadMgrEventSink, sink, &tmSinkCookie);
1026     ok(SUCCEEDED(hr),"Failed to Advise Sink\n");
1027     ok(tmSinkCookie!=0,"Failed to get sink cookie\n");
1028
1029     /* Advising the sink adds a ref, Releasing here lets the object be deleted
1030        when unadvised */
1031     tmSinkRefCount = 2;
1032     IUnknown_Release(sink);
1033     ITfSource_Release(source);
1034 }
1035
1036 static void test_ThreadMgrUnadviseSinks(void)
1037 {
1038     ITfSource *source = NULL;
1039     HRESULT hr;
1040
1041     hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfSource, (LPVOID*)&source);
1042     ok(SUCCEEDED(hr),"Failed to get IID_ITfSource for ThreadMgr\n");
1043     if (!source)
1044         return;
1045
1046     tmSinkRefCount = 1;
1047     hr = ITfSource_UnadviseSink(source, tmSinkCookie);
1048     ok(SUCCEEDED(hr),"Failed to unadvise Sink\n");
1049     ITfSource_Release(source);
1050 }
1051
1052 /**********************************************************************
1053  * ITfKeyEventSink
1054  **********************************************************************/
1055 typedef struct tagKeyEventSink
1056 {
1057     ITfKeyEventSink ITfKeyEventSink_iface;
1058     LONG refCount;
1059 } KeyEventSink;
1060
1061 static inline KeyEventSink *impl_from_ITfKeyEventSink(ITfKeyEventSink *iface)
1062 {
1063     return CONTAINING_RECORD(iface, KeyEventSink, ITfKeyEventSink_iface);
1064 }
1065
1066 static void KeyEventSink_Destructor(KeyEventSink *This)
1067 {
1068     HeapFree(GetProcessHeap(),0,This);
1069 }
1070
1071 static HRESULT WINAPI KeyEventSink_QueryInterface(ITfKeyEventSink *iface, REFIID iid, LPVOID *ppvOut)
1072 {
1073     KeyEventSink *This = impl_from_ITfKeyEventSink(iface);
1074     *ppvOut = NULL;
1075
1076     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfKeyEventSink))
1077     {
1078         *ppvOut = This;
1079     }
1080
1081     if (*ppvOut)
1082     {
1083         ITfKeyEventSink_AddRef(iface);
1084         return S_OK;
1085     }
1086
1087     return E_NOINTERFACE;
1088 }
1089
1090 static ULONG WINAPI KeyEventSink_AddRef(ITfKeyEventSink *iface)
1091 {
1092     KeyEventSink *This = impl_from_ITfKeyEventSink(iface);
1093     return InterlockedIncrement(&This->refCount);
1094 }
1095
1096 static ULONG WINAPI KeyEventSink_Release(ITfKeyEventSink *iface)
1097 {
1098     KeyEventSink *This = impl_from_ITfKeyEventSink(iface);
1099     ULONG ret;
1100
1101     ret = InterlockedDecrement(&This->refCount);
1102     if (ret == 0)
1103         KeyEventSink_Destructor(This);
1104     return ret;
1105 }
1106
1107 static HRESULT WINAPI KeyEventSink_OnSetFocus(ITfKeyEventSink *iface,
1108         BOOL fForeground)
1109 {
1110     sink_fire_ok(&test_KEV_OnSetFocus,"KeyEventSink_OnSetFocus");
1111     return S_OK;
1112 }
1113
1114 static HRESULT WINAPI KeyEventSink_OnTestKeyDown(ITfKeyEventSink *iface,
1115         ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
1116 {
1117     trace("\n");
1118     return S_OK;
1119 }
1120
1121 static HRESULT WINAPI KeyEventSink_OnTestKeyUp(ITfKeyEventSink *iface,
1122         ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
1123 {
1124     trace("\n");
1125     return S_OK;
1126 }
1127
1128 static HRESULT WINAPI KeyEventSink_OnKeyDown(ITfKeyEventSink *iface,
1129         ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
1130 {
1131     trace("\n");
1132     return S_OK;
1133 }
1134
1135 static HRESULT WINAPI KeyEventSink_OnKeyUp(ITfKeyEventSink *iface,
1136         ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
1137 {
1138     trace("\n");
1139     return S_OK;
1140 }
1141
1142 static HRESULT WINAPI KeyEventSink_OnPreservedKey(ITfKeyEventSink *iface,
1143     ITfContext *pic, REFGUID rguid, BOOL *pfEaten)
1144 {
1145     trace("\n");
1146     return S_OK;
1147 }
1148
1149 static const ITfKeyEventSinkVtbl KeyEventSink_KeyEventSinkVtbl =
1150 {
1151     KeyEventSink_QueryInterface,
1152     KeyEventSink_AddRef,
1153     KeyEventSink_Release,
1154
1155     KeyEventSink_OnSetFocus,
1156     KeyEventSink_OnTestKeyDown,
1157     KeyEventSink_OnTestKeyUp,
1158     KeyEventSink_OnKeyDown,
1159     KeyEventSink_OnKeyUp,
1160     KeyEventSink_OnPreservedKey
1161 };
1162
1163 static HRESULT KeyEventSink_Constructor(ITfKeyEventSink **ppOut)
1164 {
1165     KeyEventSink *This;
1166
1167     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(KeyEventSink));
1168     if (This == NULL)
1169         return E_OUTOFMEMORY;
1170
1171     This->ITfKeyEventSink_iface.lpVtbl = &KeyEventSink_KeyEventSinkVtbl;
1172     This->refCount = 1;
1173
1174     *ppOut = &This->ITfKeyEventSink_iface;
1175     return S_OK;
1176 }
1177
1178
1179 static void test_KeystrokeMgr(void)
1180 {
1181     ITfKeystrokeMgr *keymgr= NULL;
1182     HRESULT hr;
1183     TF_PRESERVEDKEY tfpk;
1184     BOOL preserved;
1185     ITfKeyEventSink *sink = NULL;
1186
1187     KeyEventSink_Constructor(&sink);
1188
1189     hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfKeystrokeMgr, (LPVOID*)&keymgr);
1190     ok(SUCCEEDED(hr),"Failed to get IID_ITfKeystrokeMgr for ThreadMgr\n");
1191
1192     tfpk.uVKey = 'A';
1193     tfpk.uModifiers = TF_MOD_SHIFT;
1194
1195     test_KEV_OnSetFocus = SINK_EXPECTED;
1196     hr = ITfKeystrokeMgr_AdviseKeyEventSink(keymgr,tid,sink,TRUE);
1197     ok(SUCCEEDED(hr),"ITfKeystrokeMgr_AdviseKeyEventSink failed\n");
1198     sink_check_ok(&test_KEV_OnSetFocus,"KeyEventSink_OnSetFocus");
1199     hr = ITfKeystrokeMgr_AdviseKeyEventSink(keymgr,tid,sink,TRUE);
1200     ok(hr == CONNECT_E_ADVISELIMIT,"Wrong return, expected CONNECT_E_ADVISELIMIT\n");
1201     hr = ITfKeystrokeMgr_AdviseKeyEventSink(keymgr,cid,sink,TRUE);
1202     ok(hr == E_INVALIDARG,"Wrong return, expected E_INVALIDARG\n");
1203
1204     hr =ITfKeystrokeMgr_PreserveKey(keymgr, 0, &CLSID_PreservedKey, &tfpk, NULL, 0);
1205     ok(hr==E_INVALIDARG,"ITfKeystrokeMgr_PreserveKey inproperly succeeded\n");
1206
1207     hr =ITfKeystrokeMgr_PreserveKey(keymgr, tid, &CLSID_PreservedKey, &tfpk, NULL, 0);
1208     ok(SUCCEEDED(hr),"ITfKeystrokeMgr_PreserveKey failed\n");
1209
1210     hr =ITfKeystrokeMgr_PreserveKey(keymgr, tid, &CLSID_PreservedKey, &tfpk, NULL, 0);
1211     ok(hr == TF_E_ALREADY_EXISTS,"ITfKeystrokeMgr_PreserveKey inproperly succeeded\n");
1212
1213     preserved = FALSE;
1214     hr = ITfKeystrokeMgr_IsPreservedKey(keymgr, &CLSID_PreservedKey, &tfpk, &preserved);
1215     ok(hr == S_OK, "ITfKeystrokeMgr_IsPreservedKey failed\n");
1216     if (hr == S_OK) ok(preserved == TRUE,"misreporting preserved key\n");
1217
1218     hr = ITfKeystrokeMgr_UnpreserveKey(keymgr, &CLSID_PreservedKey,&tfpk);
1219     ok(SUCCEEDED(hr),"ITfKeystrokeMgr_UnpreserveKey failed\n");
1220
1221     hr = ITfKeystrokeMgr_IsPreservedKey(keymgr, &CLSID_PreservedKey, &tfpk, &preserved);
1222     ok(hr == S_FALSE, "ITfKeystrokeMgr_IsPreservedKey failed\n");
1223     if (hr == S_FALSE) ok(preserved == FALSE,"misreporting preserved key\n");
1224
1225     hr = ITfKeystrokeMgr_UnpreserveKey(keymgr, &CLSID_PreservedKey,&tfpk);
1226     ok(hr==CONNECT_E_NOCONNECTION,"ITfKeystrokeMgr_UnpreserveKey inproperly succeeded\n");
1227
1228     hr = ITfKeystrokeMgr_UnadviseKeyEventSink(keymgr,tid);
1229     ok(SUCCEEDED(hr),"ITfKeystrokeMgr_UnadviseKeyEventSink failed\n");
1230
1231     ITfKeystrokeMgr_Release(keymgr);
1232     ITfKeyEventSink_Release(sink);
1233 }
1234
1235 static void test_Activate(void)
1236 {
1237     HRESULT hr;
1238
1239     test_ShouldActivate = TRUE; /* Win7 */
1240     hr = ITfInputProcessorProfiles_ActivateLanguageProfile(g_ipp,&CLSID_FakeService,gLangid,&CLSID_FakeService);
1241     ok(SUCCEEDED(hr),"Failed to Activate text service\n");
1242     test_ShouldActivate = FALSE;
1243 }
1244
1245
1246 static void test_EnumContexts(ITfDocumentMgr *dm, ITfContext *search)
1247 {
1248     HRESULT hr;
1249     IEnumTfContexts* pEnum;
1250     BOOL found = FALSE;
1251
1252     hr = ITfDocumentMgr_EnumContexts(dm,&pEnum);
1253     ok(SUCCEEDED(hr),"EnumContexts failed\n");
1254     if (SUCCEEDED(hr))
1255     {
1256         ULONG fetched;
1257         ITfContext *cxt;
1258         while (IEnumTfContexts_Next(pEnum, 1, &cxt, &fetched) == S_OK)
1259         {
1260             if (!search)
1261                 found = TRUE;
1262             else if (search == cxt)
1263                 found = TRUE;
1264             ITfContext_Release(cxt);
1265         }
1266         IEnumTfContexts_Release(pEnum);
1267     }
1268     if (search)
1269         ok(found,"Did not find proper ITfContext\n");
1270     else
1271         ok(!found,"Found an ITfContext we should should not have\n");
1272 }
1273
1274 static void test_EnumDocumentMgr(ITfThreadMgr *tm, ITfDocumentMgr *search, ITfDocumentMgr *absent)
1275 {
1276     HRESULT hr;
1277     IEnumTfDocumentMgrs* pEnum;
1278     BOOL found = FALSE;
1279     BOOL notfound = TRUE;
1280
1281     hr = ITfThreadMgr_EnumDocumentMgrs(tm,&pEnum);
1282     ok(SUCCEEDED(hr),"EnumDocumentMgrs failed\n");
1283     if (SUCCEEDED(hr))
1284     {
1285         ULONG fetched;
1286         ITfDocumentMgr *dm;
1287         while (IEnumTfDocumentMgrs_Next(pEnum, 1, &dm, &fetched) == S_OK)
1288         {
1289             if (!search)
1290                 found = TRUE;
1291             else if (search == dm)
1292                 found = TRUE;
1293             if (absent && dm == absent)
1294                 notfound = FALSE;
1295             ITfDocumentMgr_Release(dm);
1296         }
1297         IEnumTfDocumentMgrs_Release(pEnum);
1298     }
1299     if (search)
1300         ok(found,"Did not find proper ITfDocumentMgr\n");
1301     else
1302         ok(!found,"Found an ITfDocumentMgr we should should not have\n");
1303     if (absent)
1304         ok(notfound,"Found an ITfDocumentMgr we believe should be absent\n");
1305 }
1306
1307 static inline int check_context_refcount(ITfContext *iface)
1308 {
1309     ITfContext_AddRef(iface);
1310     return ITfContext_Release(iface);
1311 }
1312
1313
1314 /**********************************************************************
1315  * ITfTextEditSink
1316  **********************************************************************/
1317 typedef struct tagTextEditSink
1318 {
1319     ITfTextEditSink ITfTextEditSink_iface;
1320     LONG refCount;
1321 } TextEditSink;
1322
1323 static inline TextEditSink *impl_from_ITfTextEditSink(ITfTextEditSink *iface)
1324 {
1325     return CONTAINING_RECORD(iface, TextEditSink, ITfTextEditSink_iface);
1326 }
1327
1328 static void TextEditSink_Destructor(TextEditSink *This)
1329 {
1330     HeapFree(GetProcessHeap(),0,This);
1331 }
1332
1333 static HRESULT WINAPI TextEditSink_QueryInterface(ITfTextEditSink *iface, REFIID iid, LPVOID *ppvOut)
1334 {
1335     TextEditSink *This = impl_from_ITfTextEditSink(iface);
1336     *ppvOut = NULL;
1337
1338     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfTextEditSink))
1339     {
1340         *ppvOut = This;
1341     }
1342
1343     if (*ppvOut)
1344     {
1345         ITfTextEditSink_AddRef(iface);
1346         return S_OK;
1347     }
1348
1349     return E_NOINTERFACE;
1350 }
1351
1352 static ULONG WINAPI TextEditSink_AddRef(ITfTextEditSink *iface)
1353 {
1354     TextEditSink *This = impl_from_ITfTextEditSink(iface);
1355     return InterlockedIncrement(&This->refCount);
1356 }
1357
1358 static ULONG WINAPI TextEditSink_Release(ITfTextEditSink *iface)
1359 {
1360     TextEditSink *This = impl_from_ITfTextEditSink(iface);
1361     ULONG ret;
1362
1363     ret = InterlockedDecrement(&This->refCount);
1364     if (ret == 0)
1365         TextEditSink_Destructor(This);
1366     return ret;
1367 }
1368
1369 static HRESULT WINAPI TextEditSink_OnEndEdit(ITfTextEditSink *iface,
1370     ITfContext *pic, TfEditCookie ecReadOnly, ITfEditRecord *pEditRecord)
1371 {
1372     sink_fire_ok(&test_OnEndEdit,"TextEditSink_OnEndEdit");
1373     return S_OK;
1374 }
1375
1376 static const ITfTextEditSinkVtbl TextEditSink_TextEditSinkVtbl =
1377 {
1378     TextEditSink_QueryInterface,
1379     TextEditSink_AddRef,
1380     TextEditSink_Release,
1381
1382     TextEditSink_OnEndEdit
1383 };
1384
1385 static HRESULT TextEditSink_Constructor(ITfTextEditSink **ppOut)
1386 {
1387     TextEditSink *This;
1388
1389     *ppOut = NULL;
1390     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(TextEditSink));
1391     if (This == NULL)
1392         return E_OUTOFMEMORY;
1393
1394     This->ITfTextEditSink_iface.lpVtbl = &TextEditSink_TextEditSinkVtbl;
1395     This->refCount = 1;
1396
1397     *ppOut = &This->ITfTextEditSink_iface;
1398     return S_OK;
1399 }
1400
1401 static void test_startSession(void)
1402 {
1403     HRESULT hr;
1404     DWORD cnt;
1405     DWORD editCookie;
1406     ITfDocumentMgr *dmtest;
1407     ITfContext *cxt,*cxt2,*cxt3,*cxtTest;
1408     ITextStoreACP *ts;
1409     TfClientId cid2 = 0;
1410
1411     hr = ITfThreadMgr_Deactivate(g_tm);
1412     ok(hr == E_UNEXPECTED,"Deactivate should have failed with E_UNEXPECTED\n");
1413
1414     test_ShouldActivate = TRUE;
1415     hr  = ITfThreadMgr_Activate(g_tm,&cid);
1416     ok(SUCCEEDED(hr),"Failed to Activate\n");
1417     ok(cid != tid,"TextService id mistakenly matches Client id\n");
1418
1419     test_ShouldActivate = FALSE;
1420     hr = ITfThreadMgr_Activate(g_tm,&cid2);
1421     ok(SUCCEEDED(hr),"Failed to Activate\n");
1422     ok (cid == cid2, "Second activate client ID does not match\n");
1423
1424     hr = ITfThreadMgr_Deactivate(g_tm);
1425     ok(SUCCEEDED(hr),"Failed to Deactivate\n");
1426
1427     test_EnumDocumentMgr(g_tm,NULL,NULL);
1428
1429     hr = ITfThreadMgr_CreateDocumentMgr(g_tm,&g_dm);
1430     ok(SUCCEEDED(hr),"CreateDocumentMgr failed\n");
1431
1432     test_EnumDocumentMgr(g_tm,g_dm,NULL);
1433
1434     hr = ITfThreadMgr_CreateDocumentMgr(g_tm,&dmtest);
1435     ok(SUCCEEDED(hr),"CreateDocumentMgr failed\n");
1436
1437     test_EnumDocumentMgr(g_tm,dmtest,NULL);
1438
1439     ITfDocumentMgr_Release(dmtest);
1440     test_EnumDocumentMgr(g_tm,g_dm,dmtest);
1441
1442     hr = ITfThreadMgr_GetFocus(g_tm,&dmtest);
1443     ok(SUCCEEDED(hr),"GetFocus Failed\n");
1444     ok(dmtest == NULL,"Initial focus not null\n");
1445
1446     test_CurrentFocus = g_dm;
1447     test_PrevFocus = NULL;
1448     test_OnSetFocus  = SINK_OPTIONAL; /* Doesn't always fire on Win7 */
1449     hr = ITfThreadMgr_SetFocus(g_tm,g_dm);
1450     ok(SUCCEEDED(hr),"SetFocus Failed\n");
1451     sink_check_ok(&test_OnSetFocus,"OnSetFocus");
1452
1453     hr = ITfThreadMgr_GetFocus(g_tm,&dmtest);
1454     ok(SUCCEEDED(hr),"GetFocus Failed\n");
1455     ok(g_dm == dmtest,"Expected DocumentMgr not focused\n");
1456
1457     ITfDocumentMgr_Release(g_dm);
1458
1459     hr = ITfThreadMgr_GetFocus(g_tm,&dmtest);
1460     ok(SUCCEEDED(hr),"GetFocus Failed\n");
1461     ok(g_dm == dmtest,"Expected DocumentMgr not focused\n");
1462     ITfDocumentMgr_Release(dmtest);
1463
1464     hr = TextStoreACP_Constructor((IUnknown**)&ts);
1465     if (SUCCEEDED(hr))
1466     {
1467         hr = ITfDocumentMgr_CreateContext(g_dm, cid, 0, (IUnknown*)ts, &cxt, &editCookie);
1468         ok(SUCCEEDED(hr),"CreateContext Failed\n");
1469     }
1470
1471     hr = ITfDocumentMgr_CreateContext(g_dm, cid, 0, NULL, &cxt2, &editCookie);
1472     ok(SUCCEEDED(hr),"CreateContext Failed\n");
1473
1474     hr = ITfDocumentMgr_CreateContext(g_dm, cid, 0, NULL, &cxt3, &editCookie);
1475     ok(SUCCEEDED(hr),"CreateContext Failed\n");
1476
1477     test_EnumContexts(g_dm, NULL);
1478
1479     hr = ITfContext_GetDocumentMgr(cxt,&dmtest);
1480     ok(hr == S_OK, "ITfContext_GetDocumentMgr failed with %x\n",hr);
1481     ok(dmtest == g_dm, "Wrong documentmgr\n");
1482     ITfDocumentMgr_Release(dmtest);
1483
1484     cnt = check_context_refcount(cxt);
1485     test_OnPushContext = SINK_EXPECTED;
1486     test_ACP_AdviseSink = SINK_EXPECTED;
1487     test_OnInitDocumentMgr = SINK_EXPECTED;
1488     hr = ITfDocumentMgr_Push(g_dm, cxt);
1489     ok(SUCCEEDED(hr),"Push Failed\n");
1490     ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1491     sink_check_ok(&test_OnPushContext,"OnPushContext");
1492     sink_check_ok(&test_OnInitDocumentMgr,"OnInitDocumentMgr");
1493     sink_check_ok(&test_ACP_AdviseSink,"TextStoreACP_AdviseSink");
1494
1495     test_EnumContexts(g_dm, cxt);
1496
1497     hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1498     ok(SUCCEEDED(hr),"GetTop Failed\n");
1499     ok(cxtTest == cxt, "Wrong context on top\n");
1500     ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1501     cnt = ITfContext_Release(cxtTest);
1502
1503     hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1504     ok(SUCCEEDED(hr),"GetBase Failed\n");
1505     ok(cxtTest == cxt, "Wrong context on Base\n");
1506     ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1507     ITfContext_Release(cxtTest);
1508
1509     check_context_refcount(cxt2);
1510     test_OnPushContext = SINK_EXPECTED;
1511     hr = ITfDocumentMgr_Push(g_dm, cxt2);
1512     ok(SUCCEEDED(hr),"Push Failed\n");
1513     sink_check_ok(&test_OnPushContext,"OnPushContext");
1514
1515     cnt = check_context_refcount(cxt2);
1516     hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1517     ok(SUCCEEDED(hr),"GetTop Failed\n");
1518     ok(cxtTest == cxt2, "Wrong context on top\n");
1519     ok(check_context_refcount(cxt2) > cnt, "Ref count did not increase\n");
1520     ITfContext_Release(cxtTest);
1521
1522     cnt = check_context_refcount(cxt);
1523     hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1524     ok(SUCCEEDED(hr),"GetBase Failed\n");
1525     ok(cxtTest == cxt, "Wrong context on Base\n");
1526     ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1527     ITfContext_Release(cxtTest);
1528
1529     cnt = check_context_refcount(cxt3);
1530     hr = ITfDocumentMgr_Push(g_dm, cxt3);
1531     ok(FAILED(hr),"Push Succeeded\n");
1532     ok(check_context_refcount(cxt3) == cnt, "Ref changed\n");
1533
1534     cnt = check_context_refcount(cxt2);
1535     hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1536     ok(SUCCEEDED(hr),"GetTop Failed\n");
1537     ok(cxtTest == cxt2, "Wrong context on top\n");
1538     ok(check_context_refcount(cxt2) > cnt, "Ref count did not increase\n");
1539     ITfContext_Release(cxtTest);
1540
1541     cnt = check_context_refcount(cxt);
1542     hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1543     ok(SUCCEEDED(hr),"GetBase Failed\n");
1544     ok(cxtTest == cxt, "Wrong context on Base\n");
1545     ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1546     ITfContext_Release(cxtTest);
1547
1548     cnt = check_context_refcount(cxt2);
1549     test_OnPopContext = SINK_EXPECTED;
1550     hr = ITfDocumentMgr_Pop(g_dm, 0);
1551     ok(SUCCEEDED(hr),"Pop Failed\n");
1552     ok(check_context_refcount(cxt2) < cnt, "Ref count did not decrease\n");
1553     sink_check_ok(&test_OnPopContext,"OnPopContext");
1554
1555     dmtest = (void *)0xfeedface;
1556     hr = ITfContext_GetDocumentMgr(cxt2,&dmtest);
1557     ok(hr == S_FALSE, "ITfContext_GetDocumentMgr wrong rc %x\n",hr);
1558     ok(dmtest == NULL,"returned documentmgr should be null\n");
1559
1560     hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1561     ok(SUCCEEDED(hr),"GetTop Failed\n");
1562     ok(cxtTest == cxt, "Wrong context on top\n");
1563     ITfContext_Release(cxtTest);
1564
1565     hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1566     ok(SUCCEEDED(hr),"GetBase Failed\n");
1567     ok(cxtTest == cxt, "Wrong context on base\n");
1568     ITfContext_Release(cxtTest);
1569
1570     hr = ITfDocumentMgr_Pop(g_dm, 0);
1571     ok(FAILED(hr),"Pop Succeeded\n");
1572
1573     hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1574     ok(SUCCEEDED(hr),"GetTop Failed\n");
1575     ok(cxtTest == cxt, "Wrong context on top\n");
1576     ITfContext_Release(cxtTest);
1577
1578     hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1579     ok(SUCCEEDED(hr),"GetBase Failed\n");
1580     ok(cxtTest == cxt, "Wrong context on base\n");
1581     ITfContext_Release(cxtTest);
1582
1583     ITfContext_Release(cxt);
1584     ITfContext_Release(cxt2);
1585     ITfContext_Release(cxt3);
1586 }
1587
1588 static void test_endSession(void)
1589 {
1590     HRESULT hr;
1591     test_ShouldDeactivate = TRUE;
1592     test_CurrentFocus = NULL;
1593     test_PrevFocus = g_dm;
1594     test_OnSetFocus  = SINK_OPTIONAL; /* Doesn't fire on Win7 */
1595     hr = ITfThreadMgr_Deactivate(g_tm);
1596     ok(SUCCEEDED(hr),"Failed to Deactivate\n");
1597     sink_check_ok(&test_OnSetFocus,"OnSetFocus");
1598     test_OnSetFocus  = SINK_UNEXPECTED;
1599 }
1600
1601 static void test_TfGuidAtom(void)
1602 {
1603     GUID gtest,g1;
1604     HRESULT hr;
1605     TfGuidAtom atom1,atom2;
1606     BOOL equal;
1607
1608     CoCreateGuid(&gtest);
1609
1610     /* msdn reports this should return E_INVALIDARG.  However my test show it crashing (winxp)*/
1611     /*
1612     hr = ITfCategoryMgr_RegisterGUID(g_cm,&gtest,NULL);
1613     ok(hr==E_INVALIDARG,"ITfCategoryMgr_RegisterGUID should have failed\n");
1614     */
1615     hr = ITfCategoryMgr_RegisterGUID(g_cm,&gtest,&atom1);
1616     ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterGUID failed\n");
1617     hr = ITfCategoryMgr_RegisterGUID(g_cm,&gtest,&atom2);
1618     ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterGUID failed\n");
1619     ok(atom1 == atom2,"atoms do not match\n");
1620     hr = ITfCategoryMgr_GetGUID(g_cm,atom2,NULL);
1621     ok(hr==E_INVALIDARG,"ITfCategoryMgr_GetGUID should have failed\n");
1622     hr = ITfCategoryMgr_GetGUID(g_cm,atom2,&g1);
1623     ok(SUCCEEDED(hr),"ITfCategoryMgr_GetGUID failed\n");
1624     ok(IsEqualGUID(&g1,&gtest),"guids do not match\n");
1625     hr = ITfCategoryMgr_IsEqualTfGuidAtom(g_cm,atom1,&gtest,NULL);
1626     ok(hr==E_INVALIDARG,"ITfCategoryMgr_IsEqualTfGuidAtom should have failed\n");
1627     hr = ITfCategoryMgr_IsEqualTfGuidAtom(g_cm,atom1,&gtest,&equal);
1628     ok(SUCCEEDED(hr),"ITfCategoryMgr_IsEqualTfGuidAtom failed\n");
1629     ok(equal == TRUE,"Equal value invalid\n");
1630
1631     /* show that cid and tid TfClientIds are also TfGuidAtoms */
1632     hr = ITfCategoryMgr_IsEqualTfGuidAtom(g_cm,tid,&CLSID_FakeService,&equal);
1633     ok(SUCCEEDED(hr),"ITfCategoryMgr_IsEqualTfGuidAtom failed\n");
1634     ok(equal == TRUE,"Equal value invalid\n");
1635     hr = ITfCategoryMgr_GetGUID(g_cm,cid,&g1);
1636     ok(SUCCEEDED(hr),"ITfCategoryMgr_GetGUID failed\n");
1637     ok(!IsEqualGUID(&g1,&GUID_NULL),"guid should not be NULL\n");
1638 }
1639
1640 static void test_ClientId(void)
1641 {
1642     ITfClientId *pcid;
1643     TfClientId id1,id2;
1644     HRESULT hr;
1645     GUID g2;
1646
1647     hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfClientId, (LPVOID*)&pcid);
1648     ok(SUCCEEDED(hr),"Unable to acquire ITfClientId interface\n");
1649
1650     CoCreateGuid(&g2);
1651
1652     hr = ITfClientId_GetClientId(pcid,&GUID_NULL,&id1);
1653     ok(SUCCEEDED(hr),"GetClientId failed\n");
1654     hr = ITfClientId_GetClientId(pcid,&GUID_NULL,&id2);
1655     ok(SUCCEEDED(hr),"GetClientId failed\n");
1656     ok(id1==id2,"Id's for GUID_NULL do not match\n");
1657     hr = ITfClientId_GetClientId(pcid,&CLSID_FakeService,&id2);
1658     ok(SUCCEEDED(hr),"GetClientId failed\n");
1659     ok(id2!=id1,"Id matches GUID_NULL\n");
1660     ok(id2==tid,"Id for CLSID_FakeService not matching tid\n");
1661     ok(id2!=cid,"Id for CLSID_FakeService matching cid\n");
1662     hr = ITfClientId_GetClientId(pcid,&g2,&id2);
1663     ok(SUCCEEDED(hr),"GetClientId failed\n");
1664     ok(id2!=id1,"Id matches GUID_NULL\n");
1665     ok(id2!=tid,"Id for random guid matching tid\n");
1666     ok(id2!=cid,"Id for random guid matching cid\n");
1667     ITfClientId_Release(pcid);
1668 }
1669
1670 /**********************************************************************
1671  * ITfEditSession
1672  **********************************************************************/
1673 typedef struct tagEditSession
1674 {
1675     ITfEditSession ITfEditSession_iface;
1676     LONG refCount;
1677 } EditSession;
1678
1679 static inline EditSession *impl_from_ITfEditSession(ITfEditSession *iface)
1680 {
1681     return CONTAINING_RECORD(iface, EditSession, ITfEditSession_iface);
1682 }
1683
1684 static void EditSession_Destructor(EditSession *This)
1685 {
1686     HeapFree(GetProcessHeap(),0,This);
1687 }
1688
1689 static HRESULT WINAPI EditSession_QueryInterface(ITfEditSession *iface, REFIID iid, LPVOID *ppvOut)
1690 {
1691     EditSession *This = impl_from_ITfEditSession(iface);
1692     *ppvOut = NULL;
1693
1694     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfEditSession))
1695     {
1696         *ppvOut = This;
1697     }
1698
1699     if (*ppvOut)
1700     {
1701         ITfEditSession_AddRef(iface);
1702         return S_OK;
1703     }
1704
1705     return E_NOINTERFACE;
1706 }
1707
1708 static ULONG WINAPI EditSession_AddRef(ITfEditSession *iface)
1709 {
1710     EditSession *This = impl_from_ITfEditSession(iface);
1711     return InterlockedIncrement(&This->refCount);
1712 }
1713
1714 static ULONG WINAPI EditSession_Release(ITfEditSession *iface)
1715 {
1716     EditSession *This = impl_from_ITfEditSession(iface);
1717     ULONG ret;
1718
1719     ret = InterlockedDecrement(&This->refCount);
1720     if (ret == 0)
1721         EditSession_Destructor(This);
1722     return ret;
1723 }
1724
1725 static void test_InsertAtSelection(TfEditCookie ec, ITfContext *cxt)
1726 {
1727     HRESULT hr;
1728     ITfInsertAtSelection *iis;
1729     ITfRange *range=NULL;
1730     static const WCHAR txt[] = {'H','e','l','l','o',' ','W','o','r','l','d',0};
1731
1732     hr = ITfContext_QueryInterface(cxt, &IID_ITfInsertAtSelection , (LPVOID*)&iis);
1733     ok(SUCCEEDED(hr),"Failed to get ITfInsertAtSelection interface\n");
1734     test_ACP_InsertTextAtSelection = SINK_EXPECTED;
1735     hr = ITfInsertAtSelection_InsertTextAtSelection(iis, ec, 0, txt, 11, &range);
1736     ok(SUCCEEDED(hr),"ITfInsertAtSelection_InsertTextAtSelection failed %x\n",hr);
1737     sink_check_ok(&test_ACP_InsertTextAtSelection,"InsertTextAtSelection");
1738     ok(range != NULL,"No range returned\n");
1739     ITfRange_Release(range);
1740     ITfInsertAtSelection_Release(iis);
1741 }
1742
1743 static HRESULT WINAPI EditSession_DoEditSession(ITfEditSession *iface,
1744 TfEditCookie ec)
1745 {
1746     ITfContext *cxt;
1747     ITfDocumentMgr *dm;
1748     ITfRange *range;
1749     TF_SELECTION selection;
1750     ULONG fetched;
1751     HRESULT hr;
1752
1753     sink_fire_ok(&test_DoEditSession,"EditSession_DoEditSession");
1754     sink_check_ok(&test_ACP_RequestLock,"RequestLock");
1755
1756     ITfThreadMgr_GetFocus(g_tm, &dm);
1757     ITfDocumentMgr_GetTop(dm,&cxt);
1758
1759     hr = ITfContext_GetStart(cxt,ec,NULL);
1760     ok(hr == E_INVALIDARG,"Unexpected return code %x\n",hr);
1761
1762     range = (ITfRange*)0xdeaddead;
1763     hr = ITfContext_GetStart(cxt,0xdeadcafe,&range);
1764     ok(hr == TF_E_NOLOCK,"Unexpected return code %x\n",hr);
1765     ok(range == NULL,"Range not set to NULL\n");
1766
1767     hr = ITfContext_GetStart(cxt,ec,&range);
1768     ok(SUCCEEDED(hr),"Unexpected return code %x\n",hr);
1769     ok(range != NULL,"Range set to NULL\n");
1770
1771     ITfRange_Release(range);
1772
1773     hr = ITfContext_GetEnd(cxt,ec,NULL);
1774     ok(hr == E_INVALIDARG,"Unexpected return code %x\n",hr);
1775
1776     range = (ITfRange*)0xdeaddead;
1777     hr = ITfContext_GetEnd(cxt,0xdeadcafe,&range);
1778     ok(hr == TF_E_NOLOCK,"Unexpected return code %x\n",hr);
1779     ok(range == NULL,"Range not set to NULL\n");
1780
1781     test_ACP_GetEndACP = SINK_EXPECTED;
1782     hr = ITfContext_GetEnd(cxt,ec,&range);
1783     ok(SUCCEEDED(hr),"Unexpected return code %x\n",hr);
1784     ok(range != NULL,"Range set to NULL\n");
1785     sink_check_ok(&test_ACP_GetEndACP,"GetEndACP");
1786
1787     ITfRange_Release(range);
1788
1789     selection.range = NULL;
1790     test_ACP_GetSelection = SINK_EXPECTED;
1791     hr = ITfContext_GetSelection(cxt, ec, TF_DEFAULT_SELECTION, 1, &selection, &fetched);
1792     ok(SUCCEEDED(hr),"ITfContext_GetSelection failed\n");
1793     ok(fetched == 1,"fetched incorrect\n");
1794     ok(selection.range != NULL,"NULL range\n");
1795     sink_check_ok(&test_ACP_GetSelection,"ACP_GetSepection");
1796     ITfRange_Release(selection.range);
1797
1798     test_InsertAtSelection(ec, cxt);
1799
1800     test_ACP_GetEndACP = SINK_EXPECTED;
1801     hr = ITfContext_GetEnd(cxt,ec,&range);
1802     ok(SUCCEEDED(hr),"Unexpected return code %x\n",hr);
1803     ok(range != NULL,"Range set to NULL\n");
1804     sink_check_ok(&test_ACP_GetEndACP,"GetEndACP");
1805
1806     selection.range = range;
1807     selection.style.ase = TF_AE_NONE;
1808     selection.style.fInterimChar = FALSE;
1809     test_ACP_SetSelection = SINK_EXPECTED;
1810     hr = ITfContext_SetSelection(cxt, ec, 1, &selection);
1811     ok(SUCCEEDED(hr),"ITfContext_SetSelection failed\n");
1812     sink_check_ok(&test_ACP_SetSelection,"SetSelection");
1813     ITfRange_Release(range);
1814
1815     ITfContext_Release(cxt);
1816     ITfDocumentMgr_Release(dm);
1817     return 0xdeadcafe;
1818 }
1819
1820 static const ITfEditSessionVtbl EditSession_EditSessionVtbl =
1821 {
1822     EditSession_QueryInterface,
1823     EditSession_AddRef,
1824     EditSession_Release,
1825
1826     EditSession_DoEditSession
1827 };
1828
1829 static HRESULT EditSession_Constructor(ITfEditSession **ppOut)
1830 {
1831     EditSession *This;
1832
1833     *ppOut = NULL;
1834     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(EditSession));
1835     if (This == NULL)
1836         return E_OUTOFMEMORY;
1837
1838     This->ITfEditSession_iface.lpVtbl = &EditSession_EditSessionVtbl;
1839     This->refCount = 1;
1840
1841     *ppOut = &This->ITfEditSession_iface;
1842     return S_OK;
1843 }
1844
1845 static void test_TStoApplicationText(void)
1846 {
1847     HRESULT hr, hrSession;
1848     ITfEditSession *es;
1849     ITfContext *cxt;
1850     ITfDocumentMgr *dm;
1851     ITfTextEditSink *sink;
1852     ITfSource *source = NULL;
1853     DWORD editSinkCookie = -1;
1854
1855     ITfThreadMgr_GetFocus(g_tm, &dm);
1856     EditSession_Constructor(&es);
1857     ITfDocumentMgr_GetTop(dm,&cxt);
1858
1859     TextEditSink_Constructor(&sink);
1860     hr = ITfContext_QueryInterface(cxt,&IID_ITfSource,(LPVOID*)&source);
1861     ok(SUCCEEDED(hr),"Failed to get IID_ITfSource for Context\n");
1862     if (source)
1863     {
1864         hr = ITfSource_AdviseSink(source, &IID_ITfTextEditSink, (LPVOID)sink, &editSinkCookie);
1865         ok(SUCCEEDED(hr),"Failed to advise Sink\n");
1866         ok(editSinkCookie != -1,"Failed to get sink cookie\n");
1867     }
1868
1869     hrSession = 0xfeedface;
1870     /* Test no permissions flags */
1871     hr = ITfContext_RequestEditSession(cxt, tid, es, TF_ES_SYNC, &hrSession);
1872     ok(hr == E_INVALIDARG,"RequestEditSession should have failed with %x not %x\n",E_INVALIDARG,hr);
1873     ok(hrSession == E_FAIL,"hrSession should be %x not %x\n",E_FAIL,hrSession);
1874
1875     documentStatus = TS_SD_READONLY;
1876     hrSession = 0xfeedface;
1877     test_ACP_GetStatus = SINK_EXPECTED;
1878     hr = ITfContext_RequestEditSession(cxt, tid, es, TF_ES_SYNC|TF_ES_READWRITE, &hrSession);
1879     ok(SUCCEEDED(hr),"ITfContext_RequestEditSession failed\n");
1880     ok(hrSession == TS_E_READONLY,"Unexpected hrSession (%x)\n",hrSession);
1881     sink_check_ok(&test_ACP_GetStatus,"GetStatus");
1882
1883     /* signal a change to allow readwrite sessions */
1884     documentStatus = 0;
1885     test_ACP_RequestLock = SINK_EXPECTED;
1886     ITextStoreACPSink_OnStatusChange(ACPSink,documentStatus);
1887     sink_check_ok(&test_ACP_RequestLock,"RequestLock");
1888
1889     test_ACP_GetStatus = SINK_EXPECTED;
1890     test_ACP_RequestLock = SINK_EXPECTED;
1891     test_DoEditSession = SINK_EXPECTED;
1892     hrSession = 0xfeedface;
1893     test_OnEndEdit = SINK_EXPECTED;
1894     hr = ITfContext_RequestEditSession(cxt, tid, es, TF_ES_SYNC|TF_ES_READWRITE, &hrSession);
1895     ok(SUCCEEDED(hr),"ITfContext_RequestEditSession failed\n");
1896     sink_check_ok(&test_OnEndEdit,"OnEndEdit");
1897     sink_check_ok(&test_DoEditSession,"DoEditSession");
1898     sink_check_ok(&test_ACP_GetStatus,"GetStatus");
1899     ok(hrSession == 0xdeadcafe,"Unexpected hrSession (%x)\n",hrSession);
1900
1901     if (source)
1902     {
1903         hr = ITfSource_UnadviseSink(source, editSinkCookie);
1904         ok(SUCCEEDED(hr),"Failed to unadvise Sink\n");
1905         ITfSource_Release(source);
1906     }
1907     ITfTextEditSink_Release(sink);
1908     ITfContext_Release(cxt);
1909     ITfDocumentMgr_Release(dm);
1910     ITfEditSession_Release(es);
1911 }
1912
1913 static void enum_compartments(ITfCompartmentMgr *cmpmgr, REFGUID present, REFGUID absent)
1914 {
1915     BOOL found,found2;
1916     IEnumGUID *ppEnum;
1917     found = FALSE;
1918     found2 = FALSE;
1919     if (SUCCEEDED(ITfCompartmentMgr_EnumCompartments(cmpmgr, &ppEnum)))
1920     {
1921         ULONG fetched;
1922         GUID g;
1923         while (IEnumGUID_Next(ppEnum, 1, &g, &fetched) == S_OK)
1924         {
1925             WCHAR str[50];
1926             CHAR strA[50];
1927             StringFromGUID2(&g,str,sizeof(str)/sizeof(str[0]));
1928             WideCharToMultiByte(CP_ACP,0,str,-1,strA,sizeof(strA),0,0);
1929             trace("found %s\n",strA);
1930             if (present && IsEqualGUID(present,&g))
1931                 found = TRUE;
1932             if (absent && IsEqualGUID(absent, &g))
1933                 found2 = TRUE;
1934         }
1935         IEnumGUID_Release(ppEnum);
1936     }
1937     if (present)
1938         ok(found,"Did not find compartment\n");
1939     if (absent)
1940         ok(!found2,"Found compartment that should be absent\n");
1941 }
1942
1943 static void test_Compartments(void)
1944 {
1945     ITfContext *cxt;
1946     ITfDocumentMgr *dm;
1947     ITfCompartmentMgr *cmpmgr;
1948     ITfCompartment *cmp;
1949     HRESULT hr;
1950
1951     ITfThreadMgr_GetFocus(g_tm, &dm);
1952     ITfDocumentMgr_GetTop(dm,&cxt);
1953
1954     /* Global */
1955     hr = ITfThreadMgr_GetGlobalCompartment(g_tm, &cmpmgr);
1956     ok(SUCCEEDED(hr),"GetGlobalCompartment failed\n");
1957     hr = ITfCompartmentMgr_GetCompartment(cmpmgr, &GUID_COMPARTMENT_SPEECH_OPENCLOSE, &cmp);
1958     ok(SUCCEEDED(hr),"GetCompartment failed\n");
1959     ITfCompartment_Release(cmp);
1960     enum_compartments(cmpmgr,&GUID_COMPARTMENT_SPEECH_OPENCLOSE,NULL);
1961     ITfCompartmentMgr_Release(cmpmgr);
1962
1963     /* Thread */
1964     hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfCompartmentMgr, (LPVOID*)&cmpmgr);
1965     ok(SUCCEEDED(hr),"ThreadMgr QI for IID_ITfCompartmentMgr failed\n");
1966     hr = ITfCompartmentMgr_GetCompartment(cmpmgr, &CLSID_FakeService, &cmp);
1967     ok(SUCCEEDED(hr),"GetCompartment failed\n");
1968     enum_compartments(cmpmgr,&CLSID_FakeService,&GUID_COMPARTMENT_SPEECH_OPENCLOSE);
1969     ITfCompartmentMgr_ClearCompartment(cmpmgr,tid,&CLSID_FakeService);
1970     enum_compartments(cmpmgr,NULL,&CLSID_FakeService);
1971     ITfCompartmentMgr_Release(cmpmgr);
1972     ITfCompartment_Release(cmp);
1973
1974     /* DocumentMgr */
1975     hr = ITfDocumentMgr_QueryInterface(dm, &IID_ITfCompartmentMgr, (LPVOID*)&cmpmgr);
1976     ok(SUCCEEDED(hr),"DocumentMgr QI for IID_ITfCompartmentMgr failed\n");
1977
1978     hr = ITfCompartmentMgr_GetCompartment(cmpmgr, &GUID_COMPARTMENT_PERSISTMENUENABLED, &cmp);
1979     ok(SUCCEEDED(hr),"GetCompartment failed\n");
1980     enum_compartments(cmpmgr,&GUID_COMPARTMENT_PERSISTMENUENABLED,&GUID_COMPARTMENT_SPEECH_OPENCLOSE);
1981     ITfCompartmentMgr_Release(cmpmgr);
1982
1983     /* Context */
1984     hr = ITfContext_QueryInterface(cxt, &IID_ITfCompartmentMgr, (LPVOID*)&cmpmgr);
1985     ok(SUCCEEDED(hr),"Context QI for IID_ITfCompartmentMgr failed\n");
1986     enum_compartments(cmpmgr,NULL,&GUID_COMPARTMENT_PERSISTMENUENABLED);
1987     ITfCompartmentMgr_Release(cmpmgr);
1988
1989     ITfContext_Release(cxt);
1990     ITfDocumentMgr_Release(dm);
1991 }
1992
1993 static void processPendingMessages(void)
1994 {
1995     MSG msg;
1996     int diff = 200;
1997     int min_timeout = 100;
1998     DWORD time = GetTickCount() + diff;
1999
2000     while (diff > 0)
2001     {
2002         if (MsgWaitForMultipleObjects(0, NULL, FALSE, min_timeout, QS_ALLINPUT) == WAIT_TIMEOUT)
2003             break;
2004         while (PeekMessageW(&msg, 0, 0, 0, PM_REMOVE))
2005         {
2006             TranslateMessage(&msg);
2007             DispatchMessageW(&msg);
2008         }
2009         diff = time - GetTickCount();
2010     }
2011 }
2012
2013 static void test_AssociateFocus(void)
2014 {
2015     ITfDocumentMgr *dm1, *dm2, *olddm, *dmcheck, *dmorig;
2016     HWND wnd1, wnd2, wnd3;
2017     HRESULT hr;
2018
2019     ITfThreadMgr_GetFocus(g_tm, &dmorig);
2020     test_CurrentFocus = NULL;
2021     test_PrevFocus = dmorig;
2022     test_OnSetFocus  = SINK_OPTIONAL; /* Doesn't always fire on Win7 */
2023     test_ACP_GetStatus = SINK_OPTIONAL;
2024     hr = ITfThreadMgr_SetFocus(g_tm,NULL);
2025     ok(SUCCEEDED(hr),"ITfThreadMgr_SetFocus failed\n");
2026     sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2027     test_ACP_GetStatus = SINK_UNEXPECTED;
2028     ITfDocumentMgr_Release(dmorig);
2029
2030     hr = ITfThreadMgr_CreateDocumentMgr(g_tm,&dm1);
2031     ok(SUCCEEDED(hr),"CreateDocumentMgr failed\n");
2032
2033     hr = ITfThreadMgr_CreateDocumentMgr(g_tm,&dm2);
2034     ok(SUCCEEDED(hr),"CreateDocumentMgr failed\n");
2035
2036     wnd1 = CreateWindowA("edit",NULL,WS_POPUP,0,0,200,60,NULL,NULL,NULL,NULL);
2037     ok(wnd1!=NULL,"Unable to create window 1\n");
2038     wnd2 = CreateWindowA("edit",NULL,WS_POPUP,0,65,200,60,NULL,NULL,NULL,NULL);
2039     ok(wnd2!=NULL,"Unable to create window 2\n");
2040     wnd3 = CreateWindowA("edit",NULL,WS_POPUP,0,130,200,60,NULL,NULL,NULL,NULL);
2041     ok(wnd3!=NULL,"Unable to create window 3\n");
2042
2043     processPendingMessages();
2044
2045     test_OnInitDocumentMgr = SINK_OPTIONAL; /* Vista and greater */
2046     test_OnPushContext = SINK_OPTIONAL; /* Vista and greater */
2047     test_OnSetFocus = SINK_OPTIONAL; /* Win7 */
2048     test_PrevFocus = NULL;
2049     test_CurrentFocus = FOCUS_IGNORE;
2050
2051     ShowWindow(wnd1,SW_SHOWNORMAL);
2052     test_OnSetFocus = SINK_UNEXPECTED;
2053     SetFocus(wnd1);
2054     sink_check_ok(&test_OnInitDocumentMgr,"OnInitDocumentMgr");
2055     sink_check_ok(&test_OnPushContext,"OnPushContext");
2056
2057     test_OnSetFocus  = SINK_OPTIONAL; /* Vista and greater */
2058     test_ACP_RequestLock = SINK_OPTIONAL; /* Win7 x64 */
2059     test_ACP_GetSelection = SINK_OPTIONAL; /* Win7 x64 */
2060     ITfThreadMgr_GetFocus(g_tm, &test_PrevFocus);
2061     test_CurrentFocus = FOCUS_IGNORE; /* This is a default system context */
2062     processPendingMessages();
2063     sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2064     test_ACP_RequestLock = SINK_UNEXPECTED;
2065     test_ACP_GetSelection = SINK_UNEXPECTED;
2066
2067     test_CurrentFocus = dm1;
2068     test_PrevFocus = FOCUS_IGNORE;
2069     test_OnSetFocus  = SINK_OPTIONAL;
2070     test_ShouldDeactivate = SINK_OPTIONAL;
2071     hr = ITfThreadMgr_AssociateFocus(g_tm,wnd1,dm1,&olddm);
2072     ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2073     sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2074     test_ShouldDeactivate = SINK_UNEXPECTED;
2075
2076     processPendingMessages();
2077
2078     ITfThreadMgr_GetFocus(g_tm, &dmcheck);
2079     ok(dmcheck == dm1 || broken(dmcheck == dmorig /* Win7+ */), "Expected DocumentMgr not focused\n");
2080     ITfDocumentMgr_Release(dmcheck);
2081
2082     /* We need to explicitly set focus on Win7+ */
2083     test_CurrentFocus = dm1;
2084     test_PrevFocus = FOCUS_IGNORE;
2085     test_OnSetFocus = SINK_OPTIONAL; /* Doesn't always fire on Win7+ */
2086     ITfThreadMgr_SetFocus(g_tm, dm1);
2087     sink_check_ok(&test_OnSetFocus, "OnSetFocus");
2088
2089     hr = ITfThreadMgr_AssociateFocus(g_tm,wnd2,dm2,&olddm);
2090     ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2091     processPendingMessages();
2092     ITfThreadMgr_GetFocus(g_tm, &dmcheck);
2093     ok(dmcheck == dm1, "Expected DocumentMgr not focused\n");
2094     ITfDocumentMgr_Release(dmcheck);
2095
2096     hr = ITfThreadMgr_AssociateFocus(g_tm,wnd3,dm2,&olddm);
2097     ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2098     processPendingMessages();
2099     ITfThreadMgr_GetFocus(g_tm, &dmcheck);
2100     ok(dmcheck == dm1, "Expected DocumentMgr not focused\n");
2101     ITfDocumentMgr_Release(dmcheck);
2102
2103     test_CurrentFocus = FOCUS_SAVE;
2104     test_PrevFocus = FOCUS_SAVE;
2105     test_OnSetFocus = SINK_SAVE;
2106     ShowWindow(wnd2,SW_SHOWNORMAL);
2107     SetFocus(wnd2);
2108     sink_check_saved(&test_OnSetFocus,dm1,dm2,"OnSetFocus");
2109     test_CurrentFocus = FOCUS_IGNORE; /* occasional wine race */
2110     test_PrevFocus = FOCUS_IGNORE; /* occasional wine race */
2111     test_OnSetFocus = SINK_IGNORE; /* occasional wine race */
2112     processPendingMessages();
2113
2114     ShowWindow(wnd3,SW_SHOWNORMAL);
2115     SetFocus(wnd3);
2116     processPendingMessages();
2117
2118     test_CurrentFocus = FOCUS_SAVE;
2119     test_PrevFocus = FOCUS_SAVE;
2120     test_OnSetFocus = SINK_SAVE;
2121     SetFocus(wnd1);
2122     processPendingMessages();
2123     sink_check_saved(&test_OnSetFocus,dm2,dm1,"OnSetFocus");
2124
2125     hr = ITfThreadMgr_AssociateFocus(g_tm,wnd3,NULL,&olddm);
2126     ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2127     ok(olddm == dm2, "incorrect old DocumentMgr returned\n");
2128     ITfDocumentMgr_Release(olddm);
2129
2130     test_CurrentFocus = dmorig;
2131     test_PrevFocus = dm1;
2132     test_OnSetFocus  = SINK_OPTIONAL; /* Doesn't always fire on Win7+ */
2133     test_ACP_GetStatus = SINK_IGNORE;
2134     ITfThreadMgr_SetFocus(g_tm,dmorig);
2135     sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2136
2137     test_CurrentFocus = FOCUS_SAVE;
2138     test_PrevFocus = FOCUS_SAVE;
2139     test_OnSetFocus = SINK_SAVE;
2140     SetFocus(wnd3);
2141     processPendingMessages();
2142     sink_check_saved(&test_OnSetFocus,dmorig,FOCUS_IGNORE,"OnSetFocus"); /* CurrentFocus NULL on XP, system default on Vista */
2143
2144     hr = ITfThreadMgr_AssociateFocus(g_tm,wnd2,NULL,&olddm);
2145     ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2146     ok(olddm == dm2, "incorrect old DocumentMgr returned\n");
2147     ITfDocumentMgr_Release(olddm);
2148     hr = ITfThreadMgr_AssociateFocus(g_tm,wnd1,NULL,&olddm);
2149     ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2150     ok(olddm == dm1, "incorrect old DocumentMgr returned\n");
2151     ITfDocumentMgr_Release(olddm);
2152
2153     test_OnSetFocus = SINK_IGNORE; /* OnSetFocus fires a couple of times on Win7 */
2154     test_CurrentFocus = FOCUS_IGNORE;
2155     test_PrevFocus = FOCUS_IGNORE;
2156     SetFocus(wnd2);
2157     processPendingMessages();
2158     SetFocus(wnd1);
2159     processPendingMessages();
2160     test_OnSetFocus = SINK_UNEXPECTED;
2161
2162     ITfDocumentMgr_Release(dm1);
2163     ITfDocumentMgr_Release(dm2);
2164
2165     test_CurrentFocus = dmorig;
2166     test_PrevFocus = FOCUS_IGNORE;
2167     test_OnSetFocus  = SINK_OPTIONAL;
2168     test_ACP_GetStatus = SINK_IGNORE;
2169     ITfThreadMgr_SetFocus(g_tm,dmorig);
2170     sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2171
2172     test_OnSetFocus = SINK_IGNORE; /* OnSetFocus fires a couple of times on Win7 */
2173     test_CurrentFocus = FOCUS_IGNORE;
2174     test_PrevFocus = FOCUS_IGNORE;
2175     DestroyWindow(wnd1);
2176     DestroyWindow(wnd2);
2177     test_OnPopContext = SINK_OPTIONAL; /* Vista and greater */
2178     test_OnSetFocus = SINK_OPTIONAL; /* Vista and greater */
2179     ITfThreadMgr_GetFocus(g_tm, &test_PrevFocus);
2180     test_CurrentFocus = NULL;
2181     test_ShouldDeactivate = TRUE; /* Win7 */
2182     DestroyWindow(wnd3);
2183     test_ShouldDeactivate = FALSE;
2184     sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2185     sink_check_ok(&test_OnPopContext,"OnPopContext");
2186 }
2187
2188 static void test_profile_mgr(void)
2189 {
2190     IEnumTfInputProcessorProfiles *enum_profiles;
2191     ITfInputProcessorProfileMgr *ipp_mgr;
2192     HRESULT hres;
2193
2194     hres = ITfInputProcessorProfiles_QueryInterface(g_ipp, &IID_ITfInputProcessorProfileMgr, (void**)&ipp_mgr);
2195     if (hres != S_OK)
2196     {
2197         win_skip("ITfInputProcessorProfileMgr is not supported.\n");
2198         return;
2199     }
2200     ok(hres == S_OK, "Could not get ITfInputProcessorProfileMgr iface: %08x\n", hres);
2201
2202     hres = ITfInputProcessorProfileMgr_EnumProfiles(ipp_mgr, 0, &enum_profiles);
2203     ok(hres == S_OK, "EnumProfiles failed: %08x\n", hres);
2204
2205     IEnumTfInputProcessorProfiles_Release(enum_profiles);
2206
2207     ITfInputProcessorProfileMgr_Release(ipp_mgr);
2208 }
2209
2210 START_TEST(inputprocessor)
2211 {
2212     if (SUCCEEDED(initialize()))
2213     {
2214         test_Register();
2215         test_RegisterCategory();
2216         Sleep(2000); /* Win7 needs some time before the registrations become active */
2217         processPendingMessages();
2218         test_EnumLanguageProfiles();
2219         test_EnumInputProcessorInfo();
2220         test_Enable();
2221         test_ThreadMgrAdviseSinks();
2222         test_Activate();
2223         test_startSession();
2224         test_TfGuidAtom();
2225         test_ClientId();
2226         test_KeystrokeMgr();
2227         test_TStoApplicationText();
2228         test_Compartments();
2229         test_AssociateFocus();
2230         test_endSession();
2231         test_FindClosestCategory();
2232         test_Disable();
2233         test_ThreadMgrUnadviseSinks();
2234         test_UnregisterCategory();
2235         test_Unregister();
2236         test_profile_mgr();
2237     }
2238     else
2239         skip("Unable to create InputProcessor\n");
2240     cleanup();
2241 }