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