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