git.oblomov.eu Git - wine/blob - dlls/msctf/tests/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 #include "wine/test.h"
  25 #include "winuser.h"
  26 #include "initguid.h"
  27 #include "shlwapi.h"
  28 #include "shlguid.h"
  29 #include "comcat.h"
  30 #include "msctf.h"
  31 #include "olectl.h"
  32
  33 static ITfInputProcessorProfiles* g_ipp;
  34 static LANGID gLangid;
  35 static ITfCategoryMgr * g_cm = NULL;
  36 static ITfThreadMgr* g_tm = NULL;
  37 static ITfDocumentMgr *g_dm = NULL;
  38 static TfClientId cid = 0;
  39 static TfClientId tid = 0;
  40
  41 static ITextStoreACPSink *ACPSink;
  42
  43 #define SINK_UNEXPECTED 0
  44 #define SINK_EXPECTED 1
  45 #define SINK_FIRED 2
  46
  47 static BOOL test_ShouldActivate = FALSE;
  48 static BOOL test_ShouldDeactivate = FALSE;
  49
  50 static DWORD tmSinkCookie;
  51 static DWORD tmSinkRefCount;
  52 static DWORD documentStatus;
  53 static ITfDocumentMgr *test_CurrentFocus = NULL;
  54 static ITfDocumentMgr *test_PrevFocus = NULL;
  55 static INT  test_OnSetFocus = SINK_UNEXPECTED;
  56 static INT  test_OnInitDocumentMgr = SINK_UNEXPECTED;
  57 static INT  test_OnPushContext = SINK_UNEXPECTED;
  58 static INT  test_OnPopContext = SINK_UNEXPECTED;
  59 static INT  test_KEV_OnSetFocus = SINK_UNEXPECTED;
  60 static INT  test_ACP_AdviseSink = SINK_UNEXPECTED;
  61 static INT  test_ACP_GetStatus = SINK_UNEXPECTED;
  62 static INT  test_ACP_RequestLock = SINK_UNEXPECTED;
  63 static INT  test_ACP_GetEndACP = SINK_UNEXPECTED;
  64 static INT  test_ACP_GetSelection = SINK_UNEXPECTED;
  65 static INT  test_DoEditSession = SINK_UNEXPECTED;
  66 static INT  test_ACP_InsertTextAtSelection = SINK_UNEXPECTED;
  67
  68
  69 /**********************************************************************
  70  * ITextStoreACP
  71  **********************************************************************/
  72 typedef struct tagTextStoreACP
  73 {
  74     const ITextStoreACPVtbl *TextStoreACPVtbl;
  75     LONG refCount;
  76
  77 } TextStoreACP;
  78
  79 static void TextStoreACP_Destructor(TextStoreACP *This)
  80 {
  81     HeapFree(GetProcessHeap(),0,This);
  82 }
  83
  84 static HRESULT WINAPI TextStoreACP_QueryInterface(ITextStoreACP *iface, REFIID iid, LPVOID *ppvOut)
  85 {
  86     TextStoreACP *This = (TextStoreACP *)iface;
  87     *ppvOut = NULL;
  88
  89     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITextStoreACP))
  90     {
  91         *ppvOut = This;
  92     }
  93
  94     if (*ppvOut)
  95     {
  96         IUnknown_AddRef(iface);
  97         return S_OK;
  98     }
  99
 100     return E_NOINTERFACE;
 101 }
 102
 103 static ULONG WINAPI TextStoreACP_AddRef(ITextStoreACP *iface)
 104 {
 105     TextStoreACP *This = (TextStoreACP *)iface;
 106     return InterlockedIncrement(&This->refCount);
 107 }
 108
 109 static ULONG WINAPI TextStoreACP_Release(ITextStoreACP *iface)
 110 {
 111     TextStoreACP *This = (TextStoreACP *)iface;
 112     ULONG ret;
 113
 114     ret = InterlockedDecrement(&This->refCount);
 115     if (ret == 0)
 116         TextStoreACP_Destructor(This);
 117     return ret;
 118 }
 119
 120 static HRESULT WINAPI TextStoreACP_AdviseSink(ITextStoreACP *iface,
 121     REFIID riid, IUnknown *punk, DWORD dwMask)
 122 {
 123     HRESULT hr;
 124
 125     ok(test_ACP_AdviseSink == SINK_EXPECTED, "Unexpected TextStoreACP_AdviseSink sink\n");
 126     test_ACP_AdviseSink = SINK_FIRED;
 127
 128     hr = IUnknown_QueryInterface(punk, &IID_ITextStoreACPSink,(LPVOID*)(&ACPSink));
 129     ok(SUCCEEDED(hr),"Unable to QueryInterface on sink\n");
 130     return S_OK;
 131 }
 132
 133 static HRESULT WINAPI TextStoreACP_UnadviseSink(ITextStoreACP *iface,
 134     IUnknown *punk)
 135 {
 136     trace("\n");
 137     return S_OK;
 138 }
 139
 140 static HRESULT WINAPI TextStoreACP_RequestLock(ITextStoreACP *iface,
 141     DWORD dwLockFlags, HRESULT *phrSession)
 142 {
 143     ok(test_ACP_RequestLock == SINK_EXPECTED,"Unexpected TextStoreACP_RequestLock\n");
 144     test_ACP_RequestLock = SINK_FIRED;
 145     *phrSession = ITextStoreACPSink_OnLockGranted(ACPSink, dwLockFlags);
 146     return S_OK;
 147 }
 148 static HRESULT WINAPI TextStoreACP_GetStatus(ITextStoreACP *iface,
 149     TS_STATUS *pdcs)
 150 {
 151     ok(test_ACP_GetStatus  == SINK_EXPECTED, "Unexpected TextStoreACP_GetStatus\n");
 152     test_ACP_GetStatus = SINK_FIRED;
 153     pdcs->dwDynamicFlags = documentStatus;
 154     return S_OK;
 155 }
 156 static HRESULT WINAPI TextStoreACP_QueryInsert(ITextStoreACP *iface,
 157     LONG acpTestStart, LONG acpTestEnd, ULONG cch, LONG *pacpResultStart,
 158     LONG *pacpResultEnd)
 159 {
 160     trace("\n");
 161     return S_OK;
 162 }
 163 static HRESULT WINAPI TextStoreACP_GetSelection(ITextStoreACP *iface,
 164     ULONG ulIndex, ULONG ulCount, TS_SELECTION_ACP *pSelection, ULONG *pcFetched)
 165 {
 166     ok(test_ACP_GetSelection == SINK_EXPECTED, "Unexpected TextStoreACP_GetSelection\n");
 167     test_ACP_GetSelection = SINK_FIRED;
 168
 169     pSelection->acpStart = 10;
 170     pSelection->acpEnd = 20;
 171     pSelection->style.fInterimChar = 0;
 172     pSelection->style.ase = TS_AE_NONE;
 173     *pcFetched = 1;
 174
 175     return S_OK;
 176 }
 177 static HRESULT WINAPI TextStoreACP_SetSelection(ITextStoreACP *iface,
 178     ULONG ulCount, const TS_SELECTION_ACP *pSelection)
 179 {
 180     trace("\n");
 181     return S_OK;
 182 }
 183 static HRESULT WINAPI TextStoreACP_GetText(ITextStoreACP *iface,
 184     LONG acpStart, LONG acpEnd, WCHAR *pchPlain, ULONG cchPlainReq,
 185     ULONG *pcchPlainRet, TS_RUNINFO *prgRunInfo, ULONG cRunInfoReq,
 186     ULONG *pcRunInfoRet, LONG *pacpNext)
 187 {
 188     trace("\n");
 189     return S_OK;
 190 }
 191 static HRESULT WINAPI TextStoreACP_SetText(ITextStoreACP *iface,
 192     DWORD dwFlags, LONG acpStart, LONG acpEnd, const WCHAR *pchText,
 193     ULONG cch, TS_TEXTCHANGE *pChange)
 194 {
 195     trace("\n");
 196     return S_OK;
 197 }
 198 static HRESULT WINAPI TextStoreACP_GetFormattedText(ITextStoreACP *iface,
 199     LONG acpStart, LONG acpEnd, IDataObject **ppDataObject)
 200 {
 201     trace("\n");
 202     return S_OK;
 203 }
 204 static HRESULT WINAPI TextStoreACP_GetEmbedded(ITextStoreACP *iface,
 205     LONG acpPos, REFGUID rguidService, REFIID riid, IUnknown **ppunk)
 206 {
 207     trace("\n");
 208     return S_OK;
 209 }
 210 static HRESULT WINAPI TextStoreACP_QueryInsertEmbedded(ITextStoreACP *iface,
 211     const GUID *pguidService, const FORMATETC *pFormatEtc, BOOL *pfInsertable)
 212 {
 213     trace("\n");
 214     return S_OK;
 215 }
 216 static HRESULT WINAPI TextStoreACP_InsertEmbedded(ITextStoreACP *iface,
 217     DWORD dwFlags, LONG acpStart, LONG acpEnd, IDataObject *pDataObject,
 218     TS_TEXTCHANGE *pChange)
 219 {
 220     trace("\n");
 221     return S_OK;
 222 }
 223 static HRESULT WINAPI TextStoreACP_InsertTextAtSelection(ITextStoreACP *iface,
 224     DWORD dwFlags, const WCHAR *pchText, ULONG cch, LONG *pacpStart,
 225     LONG *pacpEnd, TS_TEXTCHANGE *pChange)
 226 {
 227     ok(test_ACP_InsertTextAtSelection == SINK_EXPECTED,"Unexpected TextStoreACP_InsertTextAtSelection\n");
 228     test_ACP_InsertTextAtSelection = SINK_FIRED;
 229     return S_OK;
 230 }
 231 static HRESULT WINAPI TextStoreACP_InsertEmbeddedAtSelection(ITextStoreACP *iface,
 232     DWORD dwFlags, IDataObject *pDataObject, LONG *pacpStart, LONG *pacpEnd,
 233     TS_TEXTCHANGE *pChange)
 234 {
 235     trace("\n");
 236     return S_OK;
 237 }
 238 static HRESULT WINAPI TextStoreACP_RequestSupportedAttrs(ITextStoreACP *iface,
 239     DWORD dwFlags, ULONG cFilterAttrs, const TS_ATTRID *paFilterAttrs)
 240 {
 241     trace("\n");
 242     return S_OK;
 243 }
 244 static HRESULT WINAPI TextStoreACP_RequestAttrsAtPosition(ITextStoreACP *iface,
 245     LONG acpPos, ULONG cFilterAttrs, const TS_ATTRID *paFilterAttrs,
 246     DWORD dwFlags)
 247 {
 248     trace("\n");
 249     return S_OK;
 250 }
 251 static HRESULT WINAPI TextStoreACP_RequestAttrsTransitioningAtPosition(ITextStoreACP *iface,
 252     LONG acpPos, ULONG cFilterAttrs, const TS_ATTRID *paFilterAttrs,
 253     DWORD dwFlags)
 254 {
 255     trace("\n");
 256     return S_OK;
 257 }
 258 static HRESULT WINAPI TextStoreACP_FindNextAttrTransition(ITextStoreACP *iface,
 259     LONG acpStart, LONG acpHalt, ULONG cFilterAttrs, const TS_ATTRID *paFilterAttrs,
 260     DWORD dwFlags, LONG *pacpNext, BOOL *pfFound, LONG *plFoundOffset)
 261 {
 262     trace("\n");
 263     return S_OK;
 264 }
 265 static HRESULT WINAPI TextStoreACP_RetrieveRequestedAttrs(ITextStoreACP *iface,
 266     ULONG ulCount, TS_ATTRVAL *paAttrVals, ULONG *pcFetched)
 267 {
 268     trace("\n");
 269     return S_OK;
 270 }
 271 static HRESULT WINAPI TextStoreACP_GetEndACP(ITextStoreACP *iface,
 272     LONG *pacp)
 273 {
 274     ok(test_ACP_GetEndACP == SINK_EXPECTED,"Unexpected TextStoreACP_GetEndACP\n");
 275     test_ACP_GetEndACP = SINK_FIRED;
 276     return S_OK;
 277 }
 278 static HRESULT WINAPI TextStoreACP_GetActiveView(ITextStoreACP *iface,
 279     TsViewCookie *pvcView)
 280 {
 281     trace("\n");
 282     return S_OK;
 283 }
 284 static HRESULT WINAPI TextStoreACP_GetACPFromPoint(ITextStoreACP *iface,
 285     TsViewCookie vcView, const POINT *ptScreen, DWORD dwFlags,
 286     LONG *pacp)
 287 {
 288     trace("\n");
 289     return S_OK;
 290 }
 291 static HRESULT WINAPI TextStoreACP_GetTextExt(ITextStoreACP *iface,
 292     TsViewCookie vcView, LONG acpStart, LONG acpEnd, RECT *prc,
 293     BOOL *pfClipped)
 294 {
 295     trace("\n");
 296     return S_OK;
 297 }
 298 static HRESULT WINAPI TextStoreACP_GetScreenExt(ITextStoreACP *iface,
 299     TsViewCookie vcView, RECT *prc)
 300 {
 301     trace("\n");
 302     return S_OK;
 303 }
 304 static HRESULT WINAPI TextStoreACP_GetWnd(ITextStoreACP *iface,
 305     TsViewCookie vcView, HWND *phwnd)
 306 {
 307     trace("\n");
 308     return S_OK;
 309 }
 310
 311 static const ITextStoreACPVtbl TextStoreACP_TextStoreACPVtbl =
 312 {
 313     TextStoreACP_QueryInterface,
 314     TextStoreACP_AddRef,
 315     TextStoreACP_Release,
 316
 317     TextStoreACP_AdviseSink,
 318     TextStoreACP_UnadviseSink,
 319     TextStoreACP_RequestLock,
 320     TextStoreACP_GetStatus,
 321     TextStoreACP_QueryInsert,
 322     TextStoreACP_GetSelection,
 323     TextStoreACP_SetSelection,
 324     TextStoreACP_GetText,
 325     TextStoreACP_SetText,
 326     TextStoreACP_GetFormattedText,
 327     TextStoreACP_GetEmbedded,
 328     TextStoreACP_QueryInsertEmbedded,
 329     TextStoreACP_InsertEmbedded,
 330     TextStoreACP_InsertTextAtSelection,
 331     TextStoreACP_InsertEmbeddedAtSelection,
 332     TextStoreACP_RequestSupportedAttrs,
 333     TextStoreACP_RequestAttrsAtPosition,
 334     TextStoreACP_RequestAttrsTransitioningAtPosition,
 335     TextStoreACP_FindNextAttrTransition,
 336     TextStoreACP_RetrieveRequestedAttrs,
 337     TextStoreACP_GetEndACP,
 338     TextStoreACP_GetActiveView,
 339     TextStoreACP_GetACPFromPoint,
 340     TextStoreACP_GetTextExt,
 341     TextStoreACP_GetScreenExt,
 342     TextStoreACP_GetWnd
 343 };
 344
 345 static HRESULT TextStoreACP_Constructor(IUnknown **ppOut)
 346 {
 347     TextStoreACP *This;
 348
 349     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(TextStoreACP));
 350     if (This == NULL)
 351         return E_OUTOFMEMORY;
 352
 353     This->TextStoreACPVtbl = &TextStoreACP_TextStoreACPVtbl;
 354     This->refCount = 1;
 355
 356     *ppOut = (IUnknown *)This;
 357     return S_OK;
 358 }
 359
 360 /**********************************************************************
 361  * ITfThreadMgrEventSink
 362  **********************************************************************/
 363 typedef struct tagThreadMgrEventSink
 364 {
 365     const ITfThreadMgrEventSinkVtbl *ThreadMgrEventSinkVtbl;
 366     LONG refCount;
 367 } ThreadMgrEventSink;
 368
 369 static void ThreadMgrEventSink_Destructor(ThreadMgrEventSink *This)
 370 {
 371     HeapFree(GetProcessHeap(),0,This);
 372 }
 373
 374 static HRESULT WINAPI ThreadMgrEventSink_QueryInterface(ITfThreadMgrEventSink *iface, REFIID iid, LPVOID *ppvOut)
 375 {
 376     ThreadMgrEventSink *This = (ThreadMgrEventSink *)iface;
 377     *ppvOut = NULL;
 378
 379     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfThreadMgrEventSink))
 380     {
 381         *ppvOut = This;
 382     }
 383
 384     if (*ppvOut)
 385     {
 386         IUnknown_AddRef(iface);
 387         return S_OK;
 388     }
 389
 390     return E_NOINTERFACE;
 391 }
 392
 393 static ULONG WINAPI ThreadMgrEventSink_AddRef(ITfThreadMgrEventSink *iface)
 394 {
 395     ThreadMgrEventSink *This = (ThreadMgrEventSink *)iface;
 396     ok (tmSinkRefCount == This->refCount,"ThreadMgrEventSink refcount off %i vs %i\n",This->refCount,tmSinkRefCount);
 397     return InterlockedIncrement(&This->refCount);
 398 }
 399
 400 static ULONG WINAPI ThreadMgrEventSink_Release(ITfThreadMgrEventSink *iface)
 401 {
 402     ThreadMgrEventSink *This = (ThreadMgrEventSink *)iface;
 403     ULONG ret;
 404
 405     ok (tmSinkRefCount == This->refCount,"ThreadMgrEventSink refcount off %i vs %i\n",This->refCount,tmSinkRefCount);
 406     ret = InterlockedDecrement(&This->refCount);
 407     if (ret == 0)
 408         ThreadMgrEventSink_Destructor(This);
 409     return ret;
 410 }
 411
 412 static HRESULT WINAPI ThreadMgrEventSink_OnInitDocumentMgr(ITfThreadMgrEventSink *iface,
 413 ITfDocumentMgr *pdim)
 414 {
 415     ok(test_OnInitDocumentMgr == SINK_EXPECTED, "Unexpected OnInitDocumentMgr sink\n");
 416     test_OnInitDocumentMgr = SINK_FIRED;
 417     return S_OK;
 418 }
 419
 420 static HRESULT WINAPI ThreadMgrEventSink_OnUninitDocumentMgr(ITfThreadMgrEventSink *iface,
 421 ITfDocumentMgr *pdim)
 422 {
 423     trace("\n");
 424     return S_OK;
 425 }
 426
 427 static HRESULT WINAPI ThreadMgrEventSink_OnSetFocus(ITfThreadMgrEventSink *iface,
 428 ITfDocumentMgr *pdimFocus, ITfDocumentMgr *pdimPrevFocus)
 429 {
 430     ok(test_OnSetFocus == SINK_EXPECTED, "Unexpected OnSetFocus sink\n");
 431     ok(pdimFocus == test_CurrentFocus,"Sink reports wrong focus\n");
 432     ok(pdimPrevFocus == test_PrevFocus,"Sink reports wrong previous focus\n");
 433     test_OnSetFocus = SINK_FIRED;
 434     return S_OK;
 435 }
 436
 437 static HRESULT WINAPI ThreadMgrEventSink_OnPushContext(ITfThreadMgrEventSink *iface,
 438 ITfContext *pic)
 439 {
 440     ok(test_OnPushContext == SINK_EXPECTED, "Unexpected OnPushContext sink\n");
 441     test_OnPushContext = SINK_FIRED;
 442     return S_OK;
 443 }
 444
 445 static HRESULT WINAPI ThreadMgrEventSink_OnPopContext(ITfThreadMgrEventSink *iface,
 446 ITfContext *pic)
 447 {
 448     ok(test_OnPopContext == SINK_EXPECTED, "Unexpected OnPopContext sink\n");
 449     test_OnPopContext = SINK_FIRED;
 450     return S_OK;
 451 }
 452
 453 static const ITfThreadMgrEventSinkVtbl ThreadMgrEventSink_ThreadMgrEventSinkVtbl =
 454 {
 455     ThreadMgrEventSink_QueryInterface,
 456     ThreadMgrEventSink_AddRef,
 457     ThreadMgrEventSink_Release,
 458
 459     ThreadMgrEventSink_OnInitDocumentMgr,
 460     ThreadMgrEventSink_OnUninitDocumentMgr,
 461     ThreadMgrEventSink_OnSetFocus,
 462     ThreadMgrEventSink_OnPushContext,
 463     ThreadMgrEventSink_OnPopContext
 464 };
 465
 466 static HRESULT ThreadMgrEventSink_Constructor(IUnknown **ppOut)
 467 {
 468     ThreadMgrEventSink *This;
 469
 470     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ThreadMgrEventSink));
 471     if (This == NULL)
 472         return E_OUTOFMEMORY;
 473
 474     This->ThreadMgrEventSinkVtbl = &ThreadMgrEventSink_ThreadMgrEventSinkVtbl;
 475     This->refCount = 1;
 476
 477     *ppOut = (IUnknown *)This;
 478     return S_OK;
 479 }
 480
 481
 482 /********************************************************************************************
 483  * Stub text service for testing
 484  ********************************************************************************************/
 485
 486 static LONG TS_refCount;
 487 static IClassFactory *cf;
 488 static DWORD regid;
 489
 490 typedef HRESULT (*LPFNCONSTRUCTOR)(IUnknown *pUnkOuter, IUnknown **ppvOut);
 491
 492 typedef struct tagClassFactory
 493 {
 494     const IClassFactoryVtbl *vtbl;
 495     LONG   ref;
 496     LPFNCONSTRUCTOR ctor;
 497 } ClassFactory;
 498
 499 typedef struct tagTextService
 500 {
 501     const ITfTextInputProcessorVtbl *TextInputProcessorVtbl;
 502     LONG refCount;
 503 } TextService;
 504
 505 static void ClassFactory_Destructor(ClassFactory *This)
 506 {
 507     HeapFree(GetProcessHeap(),0,This);
 508     TS_refCount--;
 509 }
 510
 511 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, LPVOID *ppvOut)
 512 {
 513     *ppvOut = NULL;
 514     if (IsEqualIID(riid, &IID_IClassFactory) || IsEqualIID(riid, &IID_IUnknown))
 515     {
 516         IClassFactory_AddRef(iface);
 517         *ppvOut = iface;
 518         return S_OK;
 519     }
 520
 521     return E_NOINTERFACE;
 522 }
 523
 524 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 525 {
 526     ClassFactory *This = (ClassFactory *)iface;
 527     return InterlockedIncrement(&This->ref);
 528 }
 529
 530 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 531 {
 532     ClassFactory *This = (ClassFactory *)iface;
 533     ULONG ret = InterlockedDecrement(&This->ref);
 534
 535     if (ret == 0)
 536         ClassFactory_Destructor(This);
 537     return ret;
 538 }
 539
 540 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *punkOuter, REFIID iid, LPVOID *ppvOut)
 541 {
 542     ClassFactory *This = (ClassFactory *)iface;
 543     HRESULT ret;
 544     IUnknown *obj;
 545
 546     ret = This->ctor(punkOuter, &obj);
 547     if (FAILED(ret))
 548         return ret;
 549     ret = IUnknown_QueryInterface(obj, iid, ppvOut);
 550     IUnknown_Release(obj);
 551     return ret;
 552 }
 553
 554 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL fLock)
 555 {
 556     if(fLock)
 557         InterlockedIncrement(&TS_refCount);
 558     else
 559         InterlockedDecrement(&TS_refCount);
 560
 561     return S_OK;
 562 }
 563
 564 static const IClassFactoryVtbl ClassFactoryVtbl = {
 565     /* IUnknown */
 566     ClassFactory_QueryInterface,
 567     ClassFactory_AddRef,
 568     ClassFactory_Release,
 569
 570     /* IClassFactory*/
 571     ClassFactory_CreateInstance,
 572     ClassFactory_LockServer
 573 };
 574
 575 static HRESULT ClassFactory_Constructor(LPFNCONSTRUCTOR ctor, LPVOID *ppvOut)
 576 {
 577     ClassFactory *This = HeapAlloc(GetProcessHeap(),0,sizeof(ClassFactory));
 578     This->vtbl = &ClassFactoryVtbl;
 579     This->ref = 1;
 580     This->ctor = ctor;
 581     *ppvOut = (LPVOID)This;
 582     TS_refCount++;
 583     return S_OK;
 584 }
 585
 586 static void TextService_Destructor(TextService *This)
 587 {
 588     HeapFree(GetProcessHeap(),0,This);
 589 }
 590
 591 static HRESULT WINAPI TextService_QueryInterface(ITfTextInputProcessor *iface, REFIID iid, LPVOID *ppvOut)
 592 {
 593     TextService *This = (TextService *)iface;
 594     *ppvOut = NULL;
 595
 596     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfTextInputProcessor))
 597     {
 598         *ppvOut = This;
 599     }
 600
 601     if (*ppvOut)
 602     {
 603         IUnknown_AddRef(iface);
 604         return S_OK;
 605     }
 606
 607     return E_NOINTERFACE;
 608 }
 609
 610 static ULONG WINAPI TextService_AddRef(ITfTextInputProcessor *iface)
 611 {
 612     TextService *This = (TextService *)iface;
 613     return InterlockedIncrement(&This->refCount);
 614 }
 615
 616 static ULONG WINAPI TextService_Release(ITfTextInputProcessor *iface)
 617 {
 618     TextService *This = (TextService *)iface;
 619     ULONG ret;
 620
 621     ret = InterlockedDecrement(&This->refCount);
 622     if (ret == 0)
 623         TextService_Destructor(This);
 624     return ret;
 625 }
 626
 627 static HRESULT WINAPI TextService_Activate(ITfTextInputProcessor *iface,
 628         ITfThreadMgr *ptim, TfClientId id)
 629 {
 630     trace("TextService_Activate\n");
 631     ok(test_ShouldActivate,"Activation came unexpectedly\n");
 632     tid = id;
 633     return S_OK;
 634 }
 635
 636 static HRESULT WINAPI TextService_Deactivate(ITfTextInputProcessor *iface)
 637 {
 638     trace("TextService_Deactivate\n");
 639     ok(test_ShouldDeactivate,"Deactivation came unexpectedly\n");
 640     return S_OK;
 641 }
 642
 643 static const ITfTextInputProcessorVtbl TextService_TextInputProcessorVtbl=
 644 {
 645     TextService_QueryInterface,
 646     TextService_AddRef,
 647     TextService_Release,
 648
 649     TextService_Activate,
 650     TextService_Deactivate
 651 };
 652
 653 static HRESULT TextService_Constructor(IUnknown *pUnkOuter, IUnknown **ppOut)
 654 {
 655     TextService *This;
 656     if (pUnkOuter)
 657         return CLASS_E_NOAGGREGATION;
 658
 659     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(TextService));
 660     if (This == NULL)
 661         return E_OUTOFMEMORY;
 662
 663     This->TextInputProcessorVtbl= &TextService_TextInputProcessorVtbl;
 664     This->refCount = 1;
 665
 666     *ppOut = (IUnknown *)This;
 667     return S_OK;
 668 }
 669
 670 static HRESULT RegisterTextService(REFCLSID rclsid)
 671 {
 672     ClassFactory_Constructor( TextService_Constructor ,(LPVOID*)&cf);
 673     return CoRegisterClassObject(rclsid, (IUnknown*) cf, CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
 674 }
 675
 676 static HRESULT UnregisterTextService()
 677 {
 678     return CoRevokeClassObject(regid);
 679 }
 680
 681 /*
 682  * The tests
 683  */
 684
 685 DEFINE_GUID(CLSID_FakeService, 0xEDE1A7AD,0x66DE,0x47E0,0xB6,0x20,0x3E,0x92,0xF8,0x24,0x6B,0xF3);
 686 DEFINE_GUID(CLSID_TF_InputProcessorProfiles, 0x33c53a50,0xf456,0x4884,0xb0,0x49,0x85,0xfd,0x64,0x3e,0xcf,0xed);
 687 DEFINE_GUID(CLSID_TF_CategoryMgr,         0xA4B544A1,0x438D,0x4B41,0x93,0x25,0x86,0x95,0x23,0xE2,0xD6,0xC7);
 688 DEFINE_GUID(GUID_TFCAT_TIP_KEYBOARD,     0x34745c63,0xb2f0,0x4784,0x8b,0x67,0x5e,0x12,0xc8,0x70,0x1a,0x31);
 689 DEFINE_GUID(GUID_TFCAT_TIP_SPEECH,       0xB5A73CD1,0x8355,0x426B,0xA1,0x61,0x25,0x98,0x08,0xF2,0x6B,0x14);
 690 DEFINE_GUID(GUID_TFCAT_TIP_HANDWRITING,  0x246ecb87,0xc2f2,0x4abe,0x90,0x5b,0xc8,0xb3,0x8a,0xdd,0x2c,0x43);
 691 DEFINE_GUID (GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER,  0x046B8C80,0x1647,0x40F7,0x9B,0x21,0xB9,0x3B,0x81,0xAA,0xBC,0x1B);
 692 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
 693 DEFINE_GUID(CLSID_TF_ThreadMgr,           0x529a9e6b,0x6587,0x4f23,0xab,0x9e,0x9c,0x7d,0x68,0x3e,0x3c,0x50);
 694 DEFINE_GUID(CLSID_PreservedKey,           0xA0ED8E55,0xCD3B,0x4274,0xB2,0x95,0xF6,0xC9,0xBA,0x2B,0x84,0x72);
 695
 696
 697 static HRESULT initialize(void)
 698 {
 699     HRESULT hr;
 700     CoInitialize(NULL);
 701     hr = CoCreateInstance (&CLSID_TF_InputProcessorProfiles, NULL,
 702           CLSCTX_INPROC_SERVER, &IID_ITfInputProcessorProfiles, (void**)&g_ipp);
 703     if (SUCCEEDED(hr))
 704         hr = CoCreateInstance (&CLSID_TF_CategoryMgr, NULL,
 705           CLSCTX_INPROC_SERVER, &IID_ITfCategoryMgr, (void**)&g_cm);
 706     if (SUCCEEDED(hr))
 707         hr = CoCreateInstance (&CLSID_TF_ThreadMgr, NULL,
 708           CLSCTX_INPROC_SERVER, &IID_ITfThreadMgr, (void**)&g_tm);
 709     return hr;
 710 }
 711
 712 static void cleanup(void)
 713 {
 714     if (g_ipp)
 715         ITfInputProcessorProfiles_Release(g_ipp);
 716     if (g_cm)
 717         ITfCategoryMgr_Release(g_cm);
 718     if (g_tm)
 719         ITfThreadMgr_Release(g_tm);
 720     CoUninitialize();
 721 }
 722
 723 static void test_Register(void)
 724 {
 725     HRESULT hr;
 726
 727     static const WCHAR szDesc[] = {'F','a','k','e',' ','W','i','n','e',' ','S','e','r','v','i','c','e',0};
 728     static const WCHAR szFile[] = {'F','a','k','e',' ','W','i','n','e',' ','S','e','r','v','i','c','e',' ','F','i','l','e',0};
 729
 730     hr = ITfInputProcessorProfiles_GetCurrentLanguage(g_ipp,&gLangid);
 731     ok(SUCCEEDED(hr),"Unable to get current language id\n");
 732     trace("Current Language %x\n",gLangid);
 733
 734     hr = RegisterTextService(&CLSID_FakeService);
 735     ok(SUCCEEDED(hr),"Unable to register COM for TextService\n");
 736     hr = ITfInputProcessorProfiles_Register(g_ipp, &CLSID_FakeService);
 737     ok(SUCCEEDED(hr),"Unable to register text service(%x)\n",hr);
 738     hr = ITfInputProcessorProfiles_AddLanguageProfile(g_ipp, &CLSID_FakeService, gLangid, &CLSID_FakeService, szDesc, sizeof(szDesc)/sizeof(WCHAR), szFile, sizeof(szFile)/sizeof(WCHAR), 1);
 739     ok(SUCCEEDED(hr),"Unable to add Language Profile (%x)\n",hr);
 740 }
 741
 742 static void test_Unregister(void)
 743 {
 744     HRESULT hr;
 745     hr = ITfInputProcessorProfiles_Unregister(g_ipp, &CLSID_FakeService);
 746     ok(SUCCEEDED(hr),"Unable to unregister text service(%x)\n",hr);
 747     UnregisterTextService();
 748 }
 749
 750 static void test_EnumInputProcessorInfo(void)
 751 {
 752     IEnumGUID *ppEnum;
 753     BOOL found = FALSE;
 754
 755     if (SUCCEEDED(ITfInputProcessorProfiles_EnumInputProcessorInfo(g_ipp, &ppEnum)))
 756     {
 757         ULONG fetched;
 758         GUID g;
 759         while (IEnumGUID_Next(ppEnum, 1, &g, &fetched) == S_OK)
 760         {
 761             if(IsEqualGUID(&g,&CLSID_FakeService))
 762                 found = TRUE;
 763         }
 764     }
 765     ok(found,"Did not find registered text service\n");
 766 }
 767
 768 static void test_EnumLanguageProfiles(void)
 769 {
 770     BOOL found = FALSE;
 771     IEnumTfLanguageProfiles *ppEnum;
 772     if (SUCCEEDED(ITfInputProcessorProfiles_EnumLanguageProfiles(g_ipp,gLangid,&ppEnum)))
 773     {
 774         TF_LANGUAGEPROFILE profile;
 775         while (IEnumTfLanguageProfiles_Next(ppEnum,1,&profile,NULL)==S_OK)
 776         {
 777             if (IsEqualGUID(&profile.clsid,&CLSID_FakeService))
 778             {
 779                 found = TRUE;
 780                 ok(profile.langid == gLangid, "LangId Incorrect\n");
 781                 ok(IsEqualGUID(&profile.catid,&GUID_TFCAT_TIP_KEYBOARD), "CatId Incorrect\n");
 782                 ok(IsEqualGUID(&profile.guidProfile,&CLSID_FakeService), "guidProfile Incorrect\n");
 783             }
 784         }
 785     }
 786     ok(found,"Registered text service not found\n");
 787 }
 788
 789 static void test_RegisterCategory(void)
 790 {
 791     HRESULT hr;
 792     hr = ITfCategoryMgr_RegisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_TIP_KEYBOARD, &CLSID_FakeService);
 793     ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterCategory failed\n");
 794     hr = ITfCategoryMgr_RegisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER, &CLSID_FakeService);
 795     ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterCategory failed\n");
 796 }
 797
 798 static void test_UnregisterCategory(void)
 799 {
 800     HRESULT hr;
 801     hr = ITfCategoryMgr_UnregisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_TIP_KEYBOARD, &CLSID_FakeService);
 802     ok(SUCCEEDED(hr),"ITfCategoryMgr_UnregisterCategory failed\n");
 803     hr = ITfCategoryMgr_UnregisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER, &CLSID_FakeService);
 804     ok(SUCCEEDED(hr),"ITfCategoryMgr_UnregisterCategory failed\n");
 805 }
 806
 807 static void test_FindClosestCategory(void)
 808 {
 809     GUID output;
 810     HRESULT hr;
 811     const GUID *list[3] = {&GUID_TFCAT_TIP_SPEECH, &GUID_TFCAT_TIP_KEYBOARD, &GUID_TFCAT_TIP_HANDWRITING};
 812
 813     hr = ITfCategoryMgr_FindClosestCategory(g_cm, &CLSID_FakeService, &output, NULL, 0);
 814     ok(SUCCEEDED(hr),"ITfCategoryMgr_FindClosestCategory failed (%x)\n",hr);
 815     ok(IsEqualGUID(&output,&GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER),"Wrong GUID\n");
 816
 817     hr = ITfCategoryMgr_FindClosestCategory(g_cm, &CLSID_FakeService, &output, list, 1);
 818     ok(SUCCEEDED(hr),"ITfCategoryMgr_FindClosestCategory failed (%x)\n",hr);
 819     ok(IsEqualGUID(&output,&GUID_NULL),"Wrong GUID\n");
 820
 821     hr = ITfCategoryMgr_FindClosestCategory(g_cm, &CLSID_FakeService, &output, list, 3);
 822     ok(SUCCEEDED(hr),"ITfCategoryMgr_FindClosestCategory failed (%x)\n",hr);
 823     ok(IsEqualGUID(&output,&GUID_TFCAT_TIP_KEYBOARD),"Wrong GUID\n");
 824 }
 825
 826 static void test_Enable(void)
 827 {
 828     HRESULT hr;
 829     BOOL enabled = FALSE;
 830
 831     hr = ITfInputProcessorProfiles_EnableLanguageProfile(g_ipp,&CLSID_FakeService, gLangid, &CLSID_FakeService, TRUE);
 832     ok(SUCCEEDED(hr),"Failed to enable text service\n");
 833     hr = ITfInputProcessorProfiles_IsEnabledLanguageProfile(g_ipp,&CLSID_FakeService, gLangid, &CLSID_FakeService, &enabled);
 834     ok(SUCCEEDED(hr),"Failed to get enabled state\n");
 835     ok(enabled == TRUE,"enabled state incorrect\n");
 836 }
 837
 838 static void test_Disable(void)
 839 {
 840     HRESULT hr;
 841
 842     trace("Disabling\n");
 843     hr = ITfInputProcessorProfiles_EnableLanguageProfile(g_ipp,&CLSID_FakeService, gLangid, &CLSID_FakeService, FALSE);
 844     ok(SUCCEEDED(hr),"Failed to disable text service\n");
 845 }
 846
 847 static void test_ThreadMgrAdviseSinks(void)
 848 {
 849     ITfSource *source = NULL;
 850     HRESULT hr;
 851     IUnknown *sink;
 852
 853     hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfSource, (LPVOID*)&source);
 854     ok(SUCCEEDED(hr),"Failed to get IID_ITfSource for ThreadMgr\n");
 855     if (!source)
 856         return;
 857
 858     hr = ThreadMgrEventSink_Constructor(&sink);
 859     ok(hr == S_OK, "got %08x\n", hr);
 860     if(FAILED(hr)) return;
 861
 862     tmSinkRefCount = 1;
 863     tmSinkCookie = 0;
 864     hr = ITfSource_AdviseSink(source,&IID_ITfThreadMgrEventSink, sink, &tmSinkCookie);
 865     ok(SUCCEEDED(hr),"Failed to Advise Sink\n");
 866     ok(tmSinkCookie!=0,"Failed to get sink cookie\n");
 867
 868     /* Advising the sink adds a ref, Relesing here lets the object be deleted
 869        when unadvised */
 870     tmSinkRefCount = 2;
 871     IUnknown_Release(sink);
 872     ITfSource_Release(source);
 873 }
 874
 875 static void test_ThreadMgrUnadviseSinks(void)
 876 {
 877     ITfSource *source = NULL;
 878     HRESULT hr;
 879
 880     hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfSource, (LPVOID*)&source);
 881     ok(SUCCEEDED(hr),"Failed to get IID_ITfSource for ThreadMgr\n");
 882     if (!source)
 883         return;
 884
 885     tmSinkRefCount = 1;
 886     hr = ITfSource_UnadviseSink(source, tmSinkCookie);
 887     ok(SUCCEEDED(hr),"Failed to unadvise Sink\n");
 888     ITfSource_Release(source);
 889 }
 890
 891 /**********************************************************************
 892  * ITfKeyEventSink
 893  **********************************************************************/
 894 typedef struct tagKeyEventSink
 895 {
 896     const ITfKeyEventSinkVtbl *KeyEventSinkVtbl;
 897     LONG refCount;
 898 } KeyEventSink;
 899
 900 static void KeyEventSink_Destructor(KeyEventSink *This)
 901 {
 902     HeapFree(GetProcessHeap(),0,This);
 903 }
 904
 905 static HRESULT WINAPI KeyEventSink_QueryInterface(ITfKeyEventSink *iface, REFIID iid, LPVOID *ppvOut)
 906 {
 907     KeyEventSink *This = (KeyEventSink *)iface;
 908     *ppvOut = NULL;
 909
 910     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfKeyEventSink))
 911     {
 912         *ppvOut = This;
 913     }
 914
 915     if (*ppvOut)
 916     {
 917         IUnknown_AddRef(iface);
 918         return S_OK;
 919     }
 920
 921     return E_NOINTERFACE;
 922 }
 923
 924 static ULONG WINAPI KeyEventSink_AddRef(ITfKeyEventSink *iface)
 925 {
 926     KeyEventSink *This = (KeyEventSink *)iface;
 927     return InterlockedIncrement(&This->refCount);
 928 }
 929
 930 static ULONG WINAPI KeyEventSink_Release(ITfKeyEventSink *iface)
 931 {
 932     KeyEventSink *This = (KeyEventSink *)iface;
 933     ULONG ret;
 934
 935     ret = InterlockedDecrement(&This->refCount);
 936     if (ret == 0)
 937         KeyEventSink_Destructor(This);
 938     return ret;
 939 }
 940
 941 static HRESULT WINAPI KeyEventSink_OnSetFocus(ITfKeyEventSink *iface,
 942         BOOL fForeground)
 943 {
 944     ok(test_KEV_OnSetFocus == SINK_EXPECTED,"Unexpected KeyEventSink_OnSetFocus\n");
 945     test_KEV_OnSetFocus = SINK_FIRED;
 946     return S_OK;
 947 }
 948
 949 static HRESULT WINAPI KeyEventSink_OnTestKeyDown(ITfKeyEventSink *iface,
 950         ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
 951 {
 952     trace("\n");
 953     return S_OK;
 954 }
 955
 956 static HRESULT WINAPI KeyEventSink_OnTestKeyUp(ITfKeyEventSink *iface,
 957         ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
 958 {
 959     trace("\n");
 960     return S_OK;
 961 }
 962
 963 static HRESULT WINAPI KeyEventSink_OnKeyDown(ITfKeyEventSink *iface,
 964         ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
 965 {
 966     trace("\n");
 967     return S_OK;
 968 }
 969
 970 static HRESULT WINAPI KeyEventSink_OnKeyUp(ITfKeyEventSink *iface,
 971         ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
 972 {
 973     trace("\n");
 974     return S_OK;
 975 }
 976
 977 static HRESULT WINAPI KeyEventSink_OnPreservedKey(ITfKeyEventSink *iface,
 978     ITfContext *pic, REFGUID rguid, BOOL *pfEaten)
 979 {
 980     trace("\n");
 981     return S_OK;
 982 }
 983
 984 static const ITfKeyEventSinkVtbl KeyEventSink_KeyEventSinkVtbl =
 985 {
 986     KeyEventSink_QueryInterface,
 987     KeyEventSink_AddRef,
 988     KeyEventSink_Release,
 989
 990     KeyEventSink_OnSetFocus,
 991     KeyEventSink_OnTestKeyDown,
 992     KeyEventSink_OnTestKeyUp,
 993     KeyEventSink_OnKeyDown,
 994     KeyEventSink_OnKeyUp,
 995     KeyEventSink_OnPreservedKey
 996 };
 997
 998 static HRESULT KeyEventSink_Constructor(ITfKeyEventSink **ppOut)
 999 {
1000     KeyEventSink *This;
1001
1002     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(KeyEventSink));
1003     if (This == NULL)
1004         return E_OUTOFMEMORY;
1005
1006     This->KeyEventSinkVtbl = &KeyEventSink_KeyEventSinkVtbl;
1007     This->refCount = 1;
1008
1009     *ppOut = (ITfKeyEventSink*)This;
1010     return S_OK;
1011 }
1012
1013
1014 static void test_KeystrokeMgr(void)
1015 {
1016     ITfKeystrokeMgr *keymgr= NULL;
1017     HRESULT hr;
1018     TF_PRESERVEDKEY tfpk;
1019     BOOL preserved;
1020     ITfKeyEventSink *sink = NULL;
1021
1022     KeyEventSink_Constructor(&sink);
1023
1024     hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfKeystrokeMgr, (LPVOID*)&keymgr);
1025     ok(SUCCEEDED(hr),"Failed to get IID_ITfKeystrokeMgr for ThreadMgr\n");
1026
1027     tfpk.uVKey = 'A';
1028     tfpk.uModifiers = TF_MOD_SHIFT;
1029
1030     test_KEV_OnSetFocus = SINK_EXPECTED;
1031     hr = ITfKeystrokeMgr_AdviseKeyEventSink(keymgr,tid,sink,TRUE);
1032     ok(SUCCEEDED(hr),"ITfKeystrokeMgr_AdviseKeyEventSink failed\n");
1033     ok(test_KEV_OnSetFocus == SINK_FIRED, "KeyEventSink_OnSetFocus not fired as expected\n");
1034     hr = ITfKeystrokeMgr_AdviseKeyEventSink(keymgr,tid,sink,TRUE);
1035     ok(hr == CONNECT_E_ADVISELIMIT,"Wrong return, expected CONNECT_E_ADVISELIMIT\n");
1036     hr = ITfKeystrokeMgr_AdviseKeyEventSink(keymgr,cid,sink,TRUE);
1037     ok(hr == E_INVALIDARG,"Wrong return, expected E_INVALIDARG\n");
1038
1039     hr =ITfKeystrokeMgr_PreserveKey(keymgr, 0, &CLSID_PreservedKey, &tfpk, NULL, 0);
1040     ok(hr==E_INVALIDARG,"ITfKeystrokeMgr_PreserveKey inproperly succeeded\n");
1041
1042     hr =ITfKeystrokeMgr_PreserveKey(keymgr, tid, &CLSID_PreservedKey, &tfpk, NULL, 0);
1043     ok(SUCCEEDED(hr),"ITfKeystrokeMgr_PreserveKey failed\n");
1044
1045     hr =ITfKeystrokeMgr_PreserveKey(keymgr, tid, &CLSID_PreservedKey, &tfpk, NULL, 0);
1046     ok(hr == TF_E_ALREADY_EXISTS,"ITfKeystrokeMgr_PreserveKey inproperly succeeded\n");
1047
1048     preserved = FALSE;
1049     hr = ITfKeystrokeMgr_IsPreservedKey(keymgr, &CLSID_PreservedKey, &tfpk, &preserved);
1050     ok(hr == S_OK, "ITfKeystrokeMgr_IsPreservedKey failed\n");
1051     if (hr == S_OK) ok(preserved == TRUE,"misreporting preserved key\n");
1052
1053     hr = ITfKeystrokeMgr_UnpreserveKey(keymgr, &CLSID_PreservedKey,&tfpk);
1054     ok(SUCCEEDED(hr),"ITfKeystrokeMgr_UnpreserveKey failed\n");
1055
1056     hr = ITfKeystrokeMgr_IsPreservedKey(keymgr, &CLSID_PreservedKey, &tfpk, &preserved);
1057     ok(hr == S_FALSE, "ITfKeystrokeMgr_IsPreservedKey failed\n");
1058     if (hr == S_FALSE) ok(preserved == FALSE,"misreporting preserved key\n");
1059
1060     hr = ITfKeystrokeMgr_UnpreserveKey(keymgr, &CLSID_PreservedKey,&tfpk);
1061     ok(hr==CONNECT_E_NOCONNECTION,"ITfKeystrokeMgr_UnpreserveKey inproperly succeeded\n");
1062
1063     hr = ITfKeystrokeMgr_UnadviseKeyEventSink(keymgr,tid);
1064     ok(SUCCEEDED(hr),"ITfKeystrokeMgr_UnadviseKeyEventSink failed\n");
1065
1066     ITfKeystrokeMgr_Release(keymgr);
1067     ITfKeyEventSink_Release(sink);
1068 }
1069
1070 static void test_Activate(void)
1071 {
1072     HRESULT hr;
1073
1074     hr = ITfInputProcessorProfiles_ActivateLanguageProfile(g_ipp,&CLSID_FakeService,gLangid,&CLSID_FakeService);
1075     ok(SUCCEEDED(hr),"Failed to Activate text service\n");
1076 }
1077
1078 static inline int check_context_refcount(ITfContext *iface)
1079 {
1080     IUnknown_AddRef(iface);
1081     return IUnknown_Release(iface);
1082 }
1083
1084 static void test_startSession(void)
1085 {
1086     HRESULT hr;
1087     DWORD cnt;
1088     DWORD editCookie;
1089     ITfDocumentMgr *dmtest;
1090     ITfContext *cxt,*cxt2,*cxt3,*cxtTest;
1091     ITextStoreACP *ts;
1092     TfClientId cid2 = 0;
1093
1094     hr = ITfThreadMgr_Deactivate(g_tm);
1095     ok(hr == E_UNEXPECTED,"Deactivate should have failed with E_UNEXPECTED\n");
1096
1097     test_ShouldActivate = TRUE;
1098     hr  = ITfThreadMgr_Activate(g_tm,&cid);
1099     ok(SUCCEEDED(hr),"Failed to Activate\n");
1100     ok(cid != tid,"TextService id mistakenly matches Client id\n");
1101
1102     test_ShouldActivate = FALSE;
1103     hr = ITfThreadMgr_Activate(g_tm,&cid2);
1104     ok(SUCCEEDED(hr),"Failed to Activate\n");
1105     ok (cid == cid2, "Second activate client ID does not match\n");
1106
1107     hr = ITfThreadMgr_Deactivate(g_tm);
1108     ok(SUCCEEDED(hr),"Failed to Deactivate\n");
1109
1110     hr = ITfThreadMgr_CreateDocumentMgr(g_tm,&g_dm);
1111     ok(SUCCEEDED(hr),"CreateDocumentMgr failed\n");
1112
1113     hr = ITfThreadMgr_GetFocus(g_tm,&dmtest);
1114     ok(SUCCEEDED(hr),"GetFocus Failed\n");
1115     ok(dmtest == NULL,"Initial focus not null\n");
1116
1117     test_CurrentFocus = g_dm;
1118     test_PrevFocus = NULL;
1119     test_OnSetFocus  = SINK_EXPECTED;
1120     hr = ITfThreadMgr_SetFocus(g_tm,g_dm);
1121     ok(SUCCEEDED(hr),"SetFocus Failed\n");
1122     ok(test_OnSetFocus == SINK_FIRED, "OnSetFocus sink not called\n");
1123     test_OnSetFocus  = SINK_UNEXPECTED;
1124
1125     hr = ITfThreadMgr_GetFocus(g_tm,&dmtest);
1126     ok(SUCCEEDED(hr),"GetFocus Failed\n");
1127     ok(g_dm == dmtest,"Expected DocumentMgr not focused\n");
1128
1129     cnt = ITfDocumentMgr_Release(g_dm);
1130     ok(cnt == 2,"DocumentMgr refcount not expected (2 vs %i)\n",cnt);
1131
1132     hr = ITfThreadMgr_GetFocus(g_tm,&dmtest);
1133     ok(SUCCEEDED(hr),"GetFocus Failed\n");
1134     ok(g_dm == dmtest,"Expected DocumentMgr not focused\n");
1135
1136     TextStoreACP_Constructor((IUnknown**)&ts);
1137
1138     hr = ITfDocumentMgr_CreateContext(g_dm, cid, 0, (IUnknown*)ts, &cxt, &editCookie);
1139     ok(SUCCEEDED(hr),"CreateContext Failed\n");
1140
1141     hr = ITfDocumentMgr_CreateContext(g_dm, cid, 0, NULL, &cxt2, &editCookie);
1142     ok(SUCCEEDED(hr),"CreateContext Failed\n");
1143
1144     hr = ITfDocumentMgr_CreateContext(g_dm, cid, 0, NULL, &cxt3, &editCookie);
1145     ok(SUCCEEDED(hr),"CreateContext Failed\n");
1146
1147     cnt = check_context_refcount(cxt);
1148     test_OnPushContext = SINK_EXPECTED;
1149     test_ACP_AdviseSink = SINK_EXPECTED;
1150     test_OnInitDocumentMgr = SINK_EXPECTED;
1151     hr = ITfDocumentMgr_Push(g_dm, cxt);
1152     ok(SUCCEEDED(hr),"Push Failed\n");
1153     ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1154     ok(test_OnPushContext == SINK_FIRED, "OnPushContext sink not fired\n");
1155     ok(test_OnInitDocumentMgr == SINK_FIRED, "OnInitDocumentMgr sink not fired\n");
1156     ok(test_ACP_AdviseSink == SINK_FIRED,"TextStoreACP_AdviseSink not fired\n");
1157
1158     hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1159     ok(SUCCEEDED(hr),"GetTop Failed\n");
1160     ok(cxtTest == cxt, "Wrong context on top\n");
1161     ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1162     cnt = ITfContext_Release(cxtTest);
1163
1164     hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1165     ok(SUCCEEDED(hr),"GetBase Failed\n");
1166     ok(cxtTest == cxt, "Wrong context on Base\n");
1167     ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1168     ITfContext_Release(cxtTest);
1169
1170     check_context_refcount(cxt2);
1171     test_OnPushContext = SINK_EXPECTED;
1172     hr = ITfDocumentMgr_Push(g_dm, cxt2);
1173     ok(SUCCEEDED(hr),"Push Failed\n");
1174     ok(test_OnPushContext == SINK_FIRED, "OnPushContext sink not fired\n");
1175
1176     cnt = check_context_refcount(cxt2);
1177     hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1178     ok(SUCCEEDED(hr),"GetTop Failed\n");
1179     ok(cxtTest == cxt2, "Wrong context on top\n");
1180     ok(check_context_refcount(cxt2) > cnt, "Ref count did not increase\n");
1181     ITfContext_Release(cxtTest);
1182
1183     cnt = check_context_refcount(cxt);
1184     hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1185     ok(SUCCEEDED(hr),"GetBase Failed\n");
1186     ok(cxtTest == cxt, "Wrong context on Base\n");
1187     ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1188     ITfContext_Release(cxtTest);
1189
1190     cnt = check_context_refcount(cxt3);
1191     hr = ITfDocumentMgr_Push(g_dm, cxt3);
1192     ok(FAILED(hr),"Push Succeeded\n");
1193     ok(check_context_refcount(cxt3) == cnt, "Ref changed\n");
1194
1195     cnt = check_context_refcount(cxt2);
1196     hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1197     ok(SUCCEEDED(hr),"GetTop Failed\n");
1198     ok(cxtTest == cxt2, "Wrong context on top\n");
1199     ok(check_context_refcount(cxt2) > cnt, "Ref count did not increase\n");
1200     ITfContext_Release(cxtTest);
1201
1202     cnt = check_context_refcount(cxt);
1203     hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1204     ok(SUCCEEDED(hr),"GetBase Failed\n");
1205     ok(cxtTest == cxt, "Wrong context on Base\n");
1206     ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1207     ITfContext_Release(cxtTest);
1208
1209     cnt = check_context_refcount(cxt2);
1210     test_OnPopContext = SINK_EXPECTED;
1211     hr = ITfDocumentMgr_Pop(g_dm, 0);
1212     ok(SUCCEEDED(hr),"Pop Failed\n");
1213     ok(check_context_refcount(cxt2) < cnt, "Ref count did not decrease\n");
1214     ok(test_OnPopContext == SINK_FIRED, "OnPopContext sink not fired\n");
1215
1216     hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1217     ok(SUCCEEDED(hr),"GetTop Failed\n");
1218     ok(cxtTest == cxt, "Wrong context on top\n");
1219     ITfContext_Release(cxtTest);
1220
1221     hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1222     ok(SUCCEEDED(hr),"GetBase Failed\n");
1223     ok(cxtTest == cxt, "Wrong context on base\n");
1224     ITfContext_Release(cxtTest);
1225
1226     hr = ITfDocumentMgr_Pop(g_dm, 0);
1227     ok(FAILED(hr),"Pop Succeeded\n");
1228
1229     hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1230     ok(SUCCEEDED(hr),"GetTop Failed\n");
1231     ok(cxtTest == cxt, "Wrong context on top\n");
1232     ITfContext_Release(cxtTest);
1233
1234     hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1235     ok(SUCCEEDED(hr),"GetBase Failed\n");
1236     ok(cxtTest == cxt, "Wrong context on base\n");
1237     ITfContext_Release(cxtTest);
1238
1239     ITfContext_Release(cxt);
1240     ITfContext_Release(cxt2);
1241     ITfContext_Release(cxt3);
1242 }
1243
1244 static void test_endSession(void)
1245 {
1246     HRESULT hr;
1247     test_ShouldDeactivate = TRUE;
1248     test_CurrentFocus = NULL;
1249     test_PrevFocus = g_dm;
1250     test_OnSetFocus  = SINK_EXPECTED;
1251     hr = ITfThreadMgr_Deactivate(g_tm);
1252     ok(SUCCEEDED(hr),"Failed to Deactivate\n");
1253     ok(test_OnSetFocus == SINK_FIRED, "OnSetFocus sink not called\n");
1254     test_OnSetFocus  = SINK_UNEXPECTED;
1255 }
1256
1257 static void test_TfGuidAtom(void)
1258 {
1259     GUID gtest,g1;
1260     HRESULT hr;
1261     TfGuidAtom atom1,atom2;
1262     BOOL equal;
1263
1264     CoCreateGuid(&gtest);
1265
1266     /* msdn reports this should return E_INVALIDARG.  However my test show it crashing (winxp)*/
1267     /*
1268     hr = ITfCategoryMgr_RegisterGUID(g_cm,&gtest,NULL);
1269     ok(hr==E_INVALIDARG,"ITfCategoryMgr_RegisterGUID should have failed\n");
1270     */
1271     hr = ITfCategoryMgr_RegisterGUID(g_cm,&gtest,&atom1);
1272     ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterGUID failed\n");
1273     hr = ITfCategoryMgr_RegisterGUID(g_cm,&gtest,&atom2);
1274     ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterGUID failed\n");
1275     ok(atom1 == atom2,"atoms do not match\n");
1276     hr = ITfCategoryMgr_GetGUID(g_cm,atom2,NULL);
1277     ok(hr==E_INVALIDARG,"ITfCategoryMgr_GetGUID should have failed\n");
1278     hr = ITfCategoryMgr_GetGUID(g_cm,atom2,&g1);
1279     ok(SUCCEEDED(hr),"ITfCategoryMgr_GetGUID failed\n");
1280     ok(IsEqualGUID(&g1,&gtest),"guids do not match\n");
1281     hr = ITfCategoryMgr_IsEqualTfGuidAtom(g_cm,atom1,&gtest,NULL);
1282     ok(hr==E_INVALIDARG,"ITfCategoryMgr_IsEqualTfGuidAtom should have failed\n");
1283     hr = ITfCategoryMgr_IsEqualTfGuidAtom(g_cm,atom1,&gtest,&equal);
1284     ok(SUCCEEDED(hr),"ITfCategoryMgr_IsEqualTfGuidAtom failed\n");
1285     ok(equal == TRUE,"Equal value invalid\n");
1286
1287     /* show that cid and tid TfClientIds are also TfGuidAtoms */
1288     hr = ITfCategoryMgr_IsEqualTfGuidAtom(g_cm,tid,&CLSID_FakeService,&equal);
1289     ok(SUCCEEDED(hr),"ITfCategoryMgr_IsEqualTfGuidAtom failed\n");
1290     ok(equal == TRUE,"Equal value invalid\n");
1291     hr = ITfCategoryMgr_GetGUID(g_cm,cid,&g1);
1292     ok(SUCCEEDED(hr),"ITfCategoryMgr_GetGUID failed\n");
1293     ok(!IsEqualGUID(&g1,&GUID_NULL),"guid should not be NULL\n");
1294 }
1295
1296 static void test_ClientId(void)
1297 {
1298     ITfClientId *pcid;
1299     TfClientId id1,id2;
1300     HRESULT hr;
1301     GUID g2;
1302
1303     hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfClientId, (LPVOID*)&pcid);
1304     ok(SUCCEEDED(hr),"Unable to aquire ITfClientId interface\n");
1305
1306     CoCreateGuid(&g2);
1307
1308     hr = ITfClientId_GetClientId(pcid,&GUID_NULL,&id1);
1309     ok(SUCCEEDED(hr),"GetClientId failed\n");
1310     hr = ITfClientId_GetClientId(pcid,&GUID_NULL,&id2);
1311     ok(SUCCEEDED(hr),"GetClientId failed\n");
1312     ok(id1==id2,"Id's for GUID_NULL do not match\n");
1313     hr = ITfClientId_GetClientId(pcid,&CLSID_FakeService,&id2);
1314     ok(SUCCEEDED(hr),"GetClientId failed\n");
1315     ok(id2!=id1,"Id matches GUID_NULL\n");
1316     ok(id2==tid,"Id for CLSID_FakeService not matching tid\n");
1317     ok(id2!=cid,"Id for CLSID_FakeService matching cid\n");
1318     hr = ITfClientId_GetClientId(pcid,&g2,&id2);
1319     ok(SUCCEEDED(hr),"GetClientId failed\n");
1320     ok(id2!=id1,"Id matches GUID_NULL\n");
1321     ok(id2!=tid,"Id for random guid matching tid\n");
1322     ok(id2!=cid,"Id for random guid matching cid\n");
1323     ITfClientId_Release(pcid);
1324 }
1325
1326 /**********************************************************************
1327  * ITfEditSession
1328  **********************************************************************/
1329 typedef struct tagEditSession
1330 {
1331     const ITfEditSessionVtbl *EditSessionVtbl;
1332     LONG refCount;
1333 } EditSession;
1334
1335 static void EditSession_Destructor(EditSession *This)
1336 {
1337     HeapFree(GetProcessHeap(),0,This);
1338 }
1339
1340 static HRESULT WINAPI EditSession_QueryInterface(ITfEditSession *iface, REFIID iid, LPVOID *ppvOut)
1341 {
1342     EditSession *This = (EditSession *)iface;
1343     *ppvOut = NULL;
1344
1345     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfEditSession))
1346     {
1347         *ppvOut = This;
1348     }
1349
1350     if (*ppvOut)
1351     {
1352         IUnknown_AddRef(iface);
1353         return S_OK;
1354     }
1355
1356     return E_NOINTERFACE;
1357 }
1358
1359 static ULONG WINAPI EditSession_AddRef(ITfEditSession *iface)
1360 {
1361     EditSession *This = (EditSession *)iface;
1362     return InterlockedIncrement(&This->refCount);
1363 }
1364
1365 static ULONG WINAPI EditSession_Release(ITfEditSession *iface)
1366 {
1367     EditSession *This = (EditSession *)iface;
1368     ULONG ret;
1369
1370     ret = InterlockedDecrement(&This->refCount);
1371     if (ret == 0)
1372         EditSession_Destructor(This);
1373     return ret;
1374 }
1375
1376 static void test_InsertAtSelection(TfEditCookie ec, ITfContext *cxt)
1377 {
1378     HRESULT hr;
1379     ITfInsertAtSelection *iis;
1380     ITfRange *range=NULL;
1381     static const WCHAR txt[] = {'H','e','l','l','o',' ','W','o','r','l','d',0};
1382
1383     hr = ITfContext_QueryInterface(cxt, &IID_ITfInsertAtSelection , (LPVOID*)&iis);
1384     ok(SUCCEEDED(hr),"Failed to get ITfInsertAtSelection interface\n");
1385     test_ACP_InsertTextAtSelection = SINK_EXPECTED;
1386     hr = ITfInsertAtSelection_InsertTextAtSelection(iis, ec, 0, txt, 11, &range);
1387     ok(SUCCEEDED(hr),"ITfInsertAtSelection_InsertTextAtSelection failed %x\n",hr);
1388     ok(test_ACP_InsertTextAtSelection == SINK_FIRED,"expected InsertTextAtSelection not fired\n");
1389     ok(range != NULL,"No range returned\n");
1390     ITfRange_Release(range);
1391     ITfInsertAtSelection_Release(iis);
1392 }
1393
1394 static HRESULT WINAPI EditSession_DoEditSession(ITfEditSession *iface,
1395 TfEditCookie ec)
1396 {
1397     ITfContext *cxt;
1398     ITfDocumentMgr *dm;
1399     ITfRange *range;
1400     TF_SELECTION selection;
1401     ULONG fetched;
1402     HRESULT hr;
1403
1404     ok(test_DoEditSession == SINK_EXPECTED, "Unexpected DoEditSession\n");
1405     ok(test_ACP_RequestLock == SINK_FIRED,"Expected RequestLock not fired\n");
1406     test_DoEditSession = SINK_FIRED;
1407
1408     ITfThreadMgr_GetFocus(g_tm, &dm);
1409     ITfDocumentMgr_GetTop(dm,&cxt);
1410
1411     hr = ITfContext_GetStart(cxt,ec,NULL);
1412     ok(hr == E_INVALIDARG,"Unexpected return code %x\n",hr);
1413
1414     range = (ITfRange*)0xdeaddead;
1415     hr = ITfContext_GetStart(cxt,0xdeadcafe,&range);
1416     ok(hr == TF_E_NOLOCK,"Unexpected return code %x\n",hr);
1417     ok(range == NULL,"Range not set to NULL\n");
1418
1419     hr = ITfContext_GetStart(cxt,ec,&range);
1420     ok(SUCCEEDED(hr),"Unexpected return code %x\n",hr);
1421     ok(range != NULL,"Range set to NULL\n");
1422
1423     ITfRange_Release(range);
1424
1425     hr = ITfContext_GetEnd(cxt,ec,NULL);
1426     ok(hr == E_INVALIDARG,"Unexpected return code %x\n",hr);
1427
1428     range = (ITfRange*)0xdeaddead;
1429     hr = ITfContext_GetEnd(cxt,0xdeadcafe,&range);
1430     ok(hr == TF_E_NOLOCK,"Unexpected return code %x\n",hr);
1431     ok(range == NULL,"Range not set to NULL\n");
1432
1433     test_ACP_GetEndACP = SINK_EXPECTED;
1434     hr = ITfContext_GetEnd(cxt,ec,&range);
1435     ok(SUCCEEDED(hr),"Unexpected return code %x\n",hr);
1436     ok(range != NULL,"Range set to NULL\n");
1437     ok(test_ACP_GetEndACP == SINK_FIRED, "GetEndACP not fired as expected\n");
1438
1439     ITfRange_Release(range);
1440
1441     selection.range = NULL;
1442     test_ACP_GetSelection = SINK_EXPECTED;
1443     hr = ITfContext_GetSelection(cxt, ec, TF_DEFAULT_SELECTION, 1, &selection, &fetched);
1444     ok(SUCCEEDED(hr),"ITfContext_GetSelection failed\n");
1445     ok(fetched == 1,"fetched incorrect\n");
1446     ok(selection.range != NULL,"NULL range\n");
1447     ok(test_ACP_GetSelection == SINK_FIRED," expected ACP_GetSepection not fired\n");
1448     ITfRange_Release(selection.range);
1449
1450     test_InsertAtSelection(ec, cxt);
1451
1452     ITfContext_Release(cxt);
1453     ITfDocumentMgr_Release(dm);
1454     return 0xdeadcafe;
1455 }
1456
1457 static const ITfEditSessionVtbl EditSession_EditSessionVtbl =
1458 {
1459     EditSession_QueryInterface,
1460     EditSession_AddRef,
1461     EditSession_Release,
1462
1463     EditSession_DoEditSession
1464 };
1465
1466 HRESULT EditSession_Constructor(ITfEditSession **ppOut)
1467 {
1468     EditSession *This;
1469
1470     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(EditSession));
1471     if (This == NULL)
1472         return E_OUTOFMEMORY;
1473
1474     This->EditSessionVtbl = &EditSession_EditSessionVtbl;
1475     This->refCount = 1;
1476
1477     *ppOut = (ITfEditSession*)This;
1478     return S_OK;
1479 }
1480
1481 static void test_TStoApplicationText(void)
1482 {
1483     HRESULT hr, hrSession;
1484     ITfEditSession *es;
1485     ITfContext *cxt;
1486     ITfDocumentMgr *dm;
1487
1488     ITfThreadMgr_GetFocus(g_tm, &dm);
1489     EditSession_Constructor(&es);
1490     ITfDocumentMgr_GetTop(dm,&cxt);
1491
1492     hrSession = 0xfeedface;
1493     /* Test no premissions flags */
1494     hr = ITfContext_RequestEditSession(cxt, tid, es, TF_ES_SYNC, &hrSession);
1495     ok(hr == E_INVALIDARG,"RequestEditSession should have failed with %x not %x\n",E_INVALIDARG,hr);
1496     ok(hrSession == E_FAIL,"hrSession should be %x not %x\n",E_FAIL,hrSession);
1497
1498     documentStatus = TS_SD_READONLY;
1499     hrSession = 0xfeedface;
1500     test_ACP_GetStatus = SINK_EXPECTED;
1501     hr = ITfContext_RequestEditSession(cxt, tid, es, TF_ES_SYNC|TF_ES_READWRITE, &hrSession);
1502     ok(SUCCEEDED(hr),"ITfContext_RequestEditSession failed\n");
1503     ok(hrSession == TS_E_READONLY,"Unexpected hrSession (%x)\n",hrSession);
1504     ok(test_ACP_GetStatus == SINK_FIRED," expected GetStatus not fired\n");
1505
1506     /* signal a change to allow readwrite sessions */
1507     documentStatus = 0;
1508     test_ACP_RequestLock = SINK_EXPECTED;
1509     ITextStoreACPSink_OnStatusChange(ACPSink,documentStatus);
1510     ok(test_ACP_RequestLock == SINK_FIRED," expected RequestLock not fired\n");
1511
1512     test_ACP_GetStatus = SINK_EXPECTED;
1513     test_ACP_RequestLock = SINK_EXPECTED;
1514     test_DoEditSession = SINK_EXPECTED;
1515     hrSession = 0xfeedface;
1516     hr = ITfContext_RequestEditSession(cxt, tid, es, TF_ES_SYNC|TF_ES_READWRITE, &hrSession);
1517     ok(SUCCEEDED(hr),"ITfContext_RequestEditSession failed\n");
1518     ok(test_ACP_RequestLock == SINK_FIRED," expected RequestLock not fired\n");
1519     ok(test_DoEditSession == SINK_FIRED," expected DoEditSession not fired\n");
1520     ok(test_ACP_GetStatus == SINK_FIRED," expected GetStatus not fired\n");
1521     ok(hrSession == 0xdeadcafe,"Unexpected hrSession (%x)\n",hrSession);
1522
1523     ITfContext_Release(cxt);
1524     ITfDocumentMgr_Release(dm);
1525     ITfEditSession_Release(es);
1526 }
1527
1528 START_TEST(inputprocessor)
1529 {
1530     if (SUCCEEDED(initialize()))
1531     {
1532         test_Register();
1533         test_RegisterCategory();
1534         test_EnumInputProcessorInfo();
1535         test_Enable();
1536         test_ThreadMgrAdviseSinks();
1537         test_Activate();
1538         test_startSession();
1539         test_TfGuidAtom();
1540         test_ClientId();
1541         test_KeystrokeMgr();
1542         test_TStoApplicationText();
1543         test_endSession();
1544         test_EnumLanguageProfiles();
1545         test_FindClosestCategory();
1546         test_Disable();
1547         test_ThreadMgrUnadviseSinks();
1548         test_UnregisterCategory();
1549         test_Unregister();
1550     }
1551     else
1552         skip("Unable to create InputProcessor\n");
1553     cleanup();
1554 }