git.oblomov.eu Git - wine/blob - dlls/msctf/tests/inputprocessor.c

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