git.oblomov.eu Git - wine/blob - dlls/oleaut32/tests/olefont.c

   1 /*
   2  * OLEFONT test program
   3  *
   4  * Copyright 2003 Marcus Meissner
   5  * Copyright 2006 (Google) Benjamin Arai
   6  *
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25 #include <math.h>
  26 #include <float.h>
  27
  28 #define COBJMACROS
  29
  30 #include <wine/test.h>
  31 #include <windef.h>
  32 #include <winbase.h>
  33 #include <winuser.h>
  34 #include <wingdi.h>
  35 #include <winnls.h>
  36 #include <winerror.h>
  37 #include <winnt.h>
  38 #include <initguid.h>
  39 #include <wtypes.h>
  40 #include <olectl.h>
  41 #include <ocidl.h>
  42
  43 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
  44
  45 static WCHAR MSSansSerif_font[] = {'M','S',' ','S','a','n','s',' ','S','e','r','i','f',0};
  46 static WCHAR system_font[] = { 'S','y','s','t','e','m',0 };
  47 static WCHAR arial_font[] = { 'A','r','i','a','l',0 };
  48 static WCHAR marlett_font[] = { 'M','a','r','l','e','t','t',0 };
  49
  50 static HMODULE hOleaut32;
  51
  52 static HRESULT (WINAPI *pOleCreateFontIndirect)(LPFONTDESC,REFIID,LPVOID*);
  53
  54 #define ok_ole_success(hr, func) ok(hr == S_OK, func " failed with error 0x%08x\n", hr)
  55
  56 /* Create a font with cySize given by lo_size, hi_size,  */
  57 /* SetRatio to ratio_logical, ratio_himetric,            */
  58 /* check that resulting hfont has height hfont_height.   */
  59 /* Various checks along the way.                         */
  60
  61 static void test_ifont_sizes(LONG lo_size, LONG hi_size,
  62         LONG ratio_logical, LONG ratio_himetric,
  63         LONG hfont_height, const char * test_name)
  64 {
  65         FONTDESC fd;
  66         LPVOID pvObj = NULL;
  67         IFont* ifnt = NULL;
  68         HFONT hfont;
  69         LOGFONT lf;
  70         CY psize;
  71         HRESULT hres;
  72
  73         fd.cbSizeofstruct = sizeof(FONTDESC);
  74         fd.lpstrName      = system_font;
  75         S(fd.cySize).Lo   = lo_size;
  76         S(fd.cySize).Hi   = hi_size;
  77         fd.sWeight        = 0;
  78         fd.sCharset       = 0;
  79         fd.fItalic        = 0;
  80         fd.fUnderline     = 0;
  81         fd.fStrikethrough = 0;
  82
  83         /* Create font, test that it worked. */
  84         hres = pOleCreateFontIndirect(&fd, &IID_IFont, &pvObj);
  85         ifnt = pvObj;
  86         ok(hres == S_OK,"%s: OCFI returns 0x%08x instead of S_OK.\n",
  87                 test_name, hres);
  88         ok(pvObj != NULL,"%s: OCFI returns NULL.\n", test_name);
  89
  90         /* Read back size.  Hi part was ignored. */
  91         hres = IFont_get_Size(ifnt, &psize);
  92         ok(hres == S_OK,"%s: IFont_get_size returns 0x%08x instead of S_OK.\n",
  93                 test_name, hres);
  94         ok(S(psize).Lo == lo_size && S(psize).Hi == 0,
  95                 "%s: get_Size: Lo=%d, Hi=%d; expected Lo=%d, Hi=0.\n",
  96                 test_name, S(psize).Lo, S(psize).Hi, lo_size);
  97
  98         /* Change ratio, check size unchanged.  Standard is 72, 2540. */
  99         hres = IFont_SetRatio(ifnt, ratio_logical, ratio_himetric);
 100         ok(hres == S_OK,"%s: IFont_SR returns 0x%08x instead of S_OK.\n",
 101                 test_name, hres);
 102         hres = IFont_get_Size(ifnt, &psize);
 103         ok(hres == S_OK,"%s: IFont_get_size returns 0x%08x instead of S_OK.\n",
 104                 test_name, hres);
 105         ok(S(psize).Lo == lo_size && S(psize).Hi == 0,
 106                 "%s: gS after SR: Lo=%d, Hi=%d; expected Lo=%d, Hi=0.\n",
 107                 test_name, S(psize).Lo, S(psize).Hi, lo_size);
 108
 109         /* Check hFont size with this ratio.  This tests an important   */
 110         /* conversion for which MSDN is very wrong.                     */
 111         hres = IFont_get_hFont (ifnt, &hfont);
 112         ok(hres == S_OK, "%s: IFont_get_hFont returns 0x%08x instead of S_OK.\n",
 113                 test_name, hres);
 114         hres = GetObject (hfont, sizeof(LOGFONT), &lf);
 115         ok(lf.lfHeight == hfont_height,
 116                 "%s: hFont has lf.lfHeight=%d, expected %d.\n",
 117                 test_name, lf.lfHeight, hfont_height);
 118
 119         /* Free IFont. */
 120         IFont_Release(ifnt);
 121 }
 122
 123 static void test_QueryInterface(void)
 124 {
 125         LPVOID pvObj = NULL;
 126         HRESULT hres;
 127         IFont*  font = NULL;
 128         LONG ret;
 129
 130         hres = pOleCreateFontIndirect(NULL, &IID_IFont, NULL);
 131         ok(hres == E_POINTER, "got 0x%08x\n", hres);
 132
 133         hres = pOleCreateFontIndirect(NULL, &IID_IFont, &pvObj);
 134         font = pvObj;
 135
 136         ok(hres == S_OK,"OCFI (NULL,..) does not return 0, but 0x%08x\n",hres);
 137         ok(font != NULL,"OCFI (NULL,..) returns NULL, instead of !NULL\n");
 138
 139         pvObj = NULL;
 140         hres = IFont_QueryInterface( font, &IID_IFont, &pvObj);
 141
 142         /* Test if QueryInterface increments ref counter for IFONTs */
 143         ret = IFont_AddRef(font);
 144         ok(ret == 3 ||
 145            broken(ret == 1), /* win95 */
 146            "IFont_QI expected ref value 3 but instead got %d\n",ret);
 147         IFont_Release(font);
 148
 149         ok(hres == S_OK,"IFont_QI does not return S_OK, but 0x%08x\n", hres);
 150         ok(pvObj != NULL,"IFont_QI does return NULL, instead of a ptr\n");
 151
 152         /* Original ref and QueryInterface ref both have to be released */
 153         IFont_Release(font);
 154         IFont_Release(font);
 155 }
 156
 157 static void test_type_info(void)
 158 {
 159         LPVOID pvObj = NULL;
 160         HRESULT hres;
 161         IFontDisp*  fontdisp = NULL;
 162         ITypeInfo* pTInfo;
 163         WCHAR name_Name[] = {'N','a','m','e',0};
 164         BSTR names[3];
 165         UINT n;
 166         LCID en_us = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),
 167                 SORT_DEFAULT);
 168         DISPPARAMS dispparams;
 169         VARIANT varresult;
 170
 171         pOleCreateFontIndirect(NULL, &IID_IFontDisp, &pvObj);
 172         fontdisp = pvObj;
 173
 174         hres = IFontDisp_GetTypeInfo(fontdisp, 0, en_us, &pTInfo);
 175         ok(hres == S_OK, "GTI returned 0x%08x instead of S_OK.\n", hres);
 176         ok(pTInfo != NULL, "GTI returned NULL.\n");
 177
 178         hres = ITypeInfo_GetNames(pTInfo, DISPID_FONT_NAME, names, 3, &n);
 179         ok(hres == S_OK, "GetNames returned 0x%08x instead of S_OK.\n", hres);
 180         ok(n == 1, "GetNames returned %d names instead of 1.\n", n);
 181         ok(!lstrcmpiW(names[0],name_Name), "DISPID_FONT_NAME doesn't get 'Names'.\n");
 182         SysFreeString(names[0]);
 183
 184         ITypeInfo_Release(pTInfo);
 185
 186         dispparams.cNamedArgs = 0;
 187         dispparams.rgdispidNamedArgs = NULL;
 188         dispparams.cArgs = 0;
 189         dispparams.rgvarg = NULL;
 190         VariantInit(&varresult);
 191         hres = IFontDisp_Invoke(fontdisp, DISPID_FONT_NAME, &IID_NULL,
 192             LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult,
 193             NULL, NULL);
 194         ok(hres == S_OK, "IFontDisp_Invoke return 0x%08x instead of S_OK.\n", hres);
 195         VariantClear(&varresult);
 196
 197         IFontDisp_Release(fontdisp);
 198 }
 199
 200 static HRESULT WINAPI FontEventsDisp_QueryInterface(
 201         IFontEventsDisp *iface,
 202     /* [in] */ REFIID riid,
 203     /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
 204 {
 205     if (IsEqualIID(riid, &IID_IFontEventsDisp) || IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
 206     {
 207         IUnknown_AddRef(iface);
 208         *ppvObject = iface;
 209         return S_OK;
 210     }
 211     else
 212     {
 213         *ppvObject = NULL;
 214         return E_NOINTERFACE;
 215     }
 216 }
 217
 218 static ULONG WINAPI FontEventsDisp_AddRef(
 219     IFontEventsDisp *iface)
 220 {
 221     return 2;
 222 }
 223
 224 static ULONG WINAPI FontEventsDisp_Release(
 225         IFontEventsDisp *iface)
 226 {
 227     return 1;
 228 }
 229
 230 static int fonteventsdisp_invoke_called = 0;
 231
 232 static HRESULT WINAPI FontEventsDisp_Invoke(
 233         IFontEventsDisp __RPC_FAR * iface,
 234     /* [in] */ DISPID dispIdMember,
 235     /* [in] */ REFIID riid,
 236     /* [in] */ LCID lcid,
 237     /* [in] */ WORD wFlags,
 238     /* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams,
 239     /* [out] */ VARIANT __RPC_FAR *pVarResult,
 240     /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo,
 241     /* [out] */ UINT __RPC_FAR *puArgErr)
 242 {
 243     static const WCHAR wszBold[] = {'B','o','l','d',0};
 244     ok(wFlags == INVOKE_FUNC, "invoke flags should have been INVOKE_FUNC instead of 0x%x\n", wFlags);
 245     ok(dispIdMember == DISPID_FONT_CHANGED, "dispIdMember should have been DISPID_FONT_CHANGED instead of 0x%x\n", dispIdMember);
 246     ok(pDispParams->cArgs == 1, "pDispParams->cArgs should have been 1 instead of %d\n", pDispParams->cArgs);
 247     ok(V_VT(&pDispParams->rgvarg[0]) == VT_BSTR, "VT of first param should have been VT_BSTR instead of %d\n", V_VT(&pDispParams->rgvarg[0]));
 248     ok(!lstrcmpW(V_BSTR(&pDispParams->rgvarg[0]), wszBold), "String in first param should have been \"Bold\"\n");
 249
 250     fonteventsdisp_invoke_called++;
 251     return S_OK;
 252 }
 253
 254 static IFontEventsDispVtbl FontEventsDisp_Vtbl =
 255 {
 256     FontEventsDisp_QueryInterface,
 257     FontEventsDisp_AddRef,
 258     FontEventsDisp_Release,
 259     NULL,
 260     NULL,
 261     NULL,
 262     FontEventsDisp_Invoke
 263 };
 264
 265 static IFontEventsDisp FontEventsDisp = { &FontEventsDisp_Vtbl };
 266
 267 static void test_font_events_disp(void)
 268 {
 269     IFont *pFont;
 270     IFont *pFont2;
 271     IConnectionPointContainer *pCPC;
 272     IConnectionPoint *pCP;
 273     FONTDESC fontdesc;
 274     HRESULT hr;
 275     DWORD dwCookie;
 276     IFontDisp *pFontDisp;
 277     DISPPARAMS dispparams;
 278     VARIANTARG vararg;
 279
 280     fontdesc.cbSizeofstruct = sizeof(fontdesc);
 281     fontdesc.lpstrName = MSSansSerif_font;
 282     fontdesc.cySize.int64 = 12 * 10000; /* 12 pt */
 283     fontdesc.sWeight = FW_NORMAL;
 284     fontdesc.sCharset = 0;
 285     fontdesc.fItalic = FALSE;
 286     fontdesc.fUnderline = FALSE;
 287     fontdesc.fStrikethrough = FALSE;
 288
 289     hr = pOleCreateFontIndirect(&fontdesc, &IID_IFont, (void **)&pFont);
 290     ok_ole_success(hr, "OleCreateFontIndirect");
 291
 292     hr = IFont_QueryInterface(pFont, &IID_IConnectionPointContainer, (void **)&pCPC);
 293     ok_ole_success(hr, "IFont_QueryInterface");
 294
 295     hr = IConnectionPointContainer_FindConnectionPoint(pCPC, &IID_IFontEventsDisp, &pCP);
 296     ok_ole_success(hr, "IConnectionPointContainer_FindConnectionPoint");
 297     IConnectionPointContainer_Release(pCPC);
 298
 299     hr = IConnectionPoint_Advise(pCP, (IUnknown *)&FontEventsDisp, &dwCookie);
 300     ok_ole_success(hr, "IConnectionPoint_Advise");
 301     IConnectionPoint_Release(pCP);
 302
 303     hr = IFont_put_Bold(pFont, TRUE);
 304     ok_ole_success(hr, "IFont_put_Bold");
 305
 306     ok(fonteventsdisp_invoke_called == 1, "IFontEventDisp::Invoke wasn't called once\n");
 307
 308     hr = IFont_QueryInterface(pFont, &IID_IFontDisp, (void **)&pFontDisp);
 309     ok_ole_success(hr, "IFont_QueryInterface");
 310
 311     V_VT(&vararg) = VT_BOOL;
 312     V_BOOL(&vararg) = VARIANT_FALSE;
 313     dispparams.cNamedArgs = 0;
 314     dispparams.rgdispidNamedArgs = NULL;
 315     dispparams.cArgs = 1;
 316     dispparams.rgvarg = &vararg;
 317     hr = IFontDisp_Invoke(pFontDisp, DISPID_FONT_BOLD, &IID_NULL, 0, DISPATCH_PROPERTYPUT, &dispparams, NULL, NULL, NULL);
 318
 319     IFontDisp_Release(pFontDisp);
 320
 321     ok(fonteventsdisp_invoke_called == 2, "IFontEventDisp::Invoke was called %d times instead of twice\n",
 322         fonteventsdisp_invoke_called);
 323
 324     hr = IFont_Clone(pFont, &pFont2);
 325     ok_ole_success(hr, "IFont_Clone");
 326     IFont_Release(pFont);
 327
 328     hr = IFont_put_Bold(pFont2, FALSE);
 329     ok_ole_success(hr, "IFont_put_Bold");
 330
 331     /* this test shows that the notification routine isn't called again */
 332     ok(fonteventsdisp_invoke_called == 2, "IFontEventDisp::Invoke was called %d times instead of twice\n",
 333         fonteventsdisp_invoke_called);
 334
 335     IFont_Release(pFont2);
 336 }
 337
 338 static void test_names_ids(WCHAR* w_name_1, const char* a_name_1,
 339                     WCHAR* w_name_2, const char* a_name_2,
 340                     LCID lcid, DISPID id_1, DISPID id_2,
 341                     HRESULT hres_expect, int numnames)
 342 {
 343     LPVOID pvObj = NULL;
 344     IFontDisp *fontdisp = NULL;
 345     HRESULT hres;
 346     DISPID rgDispId[2] = {0xdeadbeef, 0xdeadbeef};
 347     LPOLESTR names[2] = {w_name_1, w_name_2};
 348
 349     pOleCreateFontIndirect(NULL, &IID_IFontDisp, &pvObj);
 350     fontdisp = pvObj;
 351
 352     hres = IFontDisp_GetIDsOfNames(fontdisp, &IID_NULL, names, numnames,
 353                                    lcid, rgDispId);
 354
 355     /* test hres */
 356     ok(hres == hres_expect,
 357         "GetIDsOfNames: \"%s\", \"%s\" returns 0x%08x, expected 0x%08x.\n",
 358         a_name_1, a_name_2, hres, hres_expect);
 359
 360     /* test first DISPID */
 361     ok(rgDispId[0]==id_1,
 362         "GetIDsOfNames: \"%s\" gets DISPID 0x%08x, expected 0x%08x.\n",
 363         a_name_1, rgDispId[0], id_1);
 364
 365     /* test second DISPID is present */
 366     if (numnames == 2)
 367     {
 368         ok(rgDispId[1]==id_2,
 369             "GetIDsOfNames: ..., \"%s\" gets DISPID 0x%08x, expected 0x%08x.\n",
 370             a_name_2, rgDispId[1], id_2);
 371     }
 372
 373    IFontDisp_Release(fontdisp);
 374 }
 375
 376 static void test_GetIDsOfNames(void)
 377 {
 378     WCHAR name_Name[] = {'N','a','m','e',0};
 379     WCHAR name_Italic[] = {'I','t','a','l','i','c',0};
 380     WCHAR name_Size[] = {'S','i','z','e',0};
 381     WCHAR name_Bold[] = {'B','o','l','d',0};
 382     WCHAR name_Underline[] = {'U','n','d','e','r','l','i','n','e',0};
 383     WCHAR name_Strikethrough[] = {'S','t','r','i','k','e','t','h','r','o','u','g','h',0};
 384     WCHAR name_Weight[] = {'W','e','i','g','h','t',0};
 385     WCHAR name_Charset[] = {'C','h','a','r','s','e','t',0};
 386     WCHAR name_Foo[] = {'F','o','o',0};
 387     WCHAR name_nAmE[] = {'n','A','m','E',0};
 388     WCHAR name_Nom[] = {'N','o','m',0};
 389
 390     LCID en_us = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),
 391                           SORT_DEFAULT);
 392     LCID fr_fr = MAKELCID(MAKELANGID(LANG_FRENCH,SUBLANG_FRENCH),
 393                           SORT_DEFAULT);
 394
 395     /* Test DISPID_FONTs for the various properties. */
 396     test_names_ids(name_Name, "Name", NULL, "", en_us,
 397                    DISPID_FONT_NAME, 0, S_OK,1);
 398     test_names_ids(name_Size, "Size", NULL, "", en_us,
 399                    DISPID_FONT_SIZE, 0, S_OK,1);
 400     test_names_ids(name_Bold, "Bold", NULL, "", en_us,
 401                    DISPID_FONT_BOLD, 0, S_OK,1);
 402     test_names_ids(name_Italic, "Italic", NULL, "", en_us,
 403                    DISPID_FONT_ITALIC, 0, S_OK,1);
 404     test_names_ids(name_Underline, "Underline", NULL, "", en_us,
 405                    DISPID_FONT_UNDER, 0, S_OK,1);
 406     test_names_ids(name_Strikethrough, "Strikethrough", NULL, "", en_us,
 407                    DISPID_FONT_STRIKE, 0, S_OK,1);
 408     test_names_ids(name_Weight, "Weight", NULL, "", en_us,
 409                    DISPID_FONT_WEIGHT, 0, S_OK,1);
 410     test_names_ids(name_Charset, "Charset", NULL, "", en_us,
 411                    DISPID_FONT_CHARSET, 0, S_OK,1);
 412
 413     /* Capitalization doesn't matter. */
 414     test_names_ids(name_nAmE, "nAmE", NULL, "", en_us,
 415                    DISPID_FONT_NAME, 0, S_OK,1);
 416
 417     /* Unknown name. */
 418     test_names_ids(name_Foo, "Foo", NULL, "", en_us,
 419                    DISPID_UNKNOWN, 0, DISP_E_UNKNOWNNAME,1);
 420
 421     /* Pass several names: first is processed,                */
 422     /* second gets DISPID_UNKNOWN and doesn't affect retval.  */
 423     test_names_ids(name_Italic, "Italic", name_Name, "Name", en_us,
 424                    DISPID_FONT_ITALIC, DISPID_UNKNOWN, S_OK,2);
 425     test_names_ids(name_Italic, "Italic", name_Foo, "Foo", en_us,
 426                    DISPID_FONT_ITALIC, DISPID_UNKNOWN, S_OK,2);
 427
 428     /* Locale ID has no effect. */
 429     test_names_ids(name_Name, "Name", NULL, "", fr_fr,
 430                    DISPID_FONT_NAME, 0, S_OK,1);
 431     test_names_ids(name_Nom, "This is not a font", NULL, "", fr_fr,
 432                    DISPID_UNKNOWN, 0, DISP_E_UNKNOWNNAME,1);
 433
 434     /* One of the arguments are invalid */
 435     test_names_ids(name_Name, "Name", NULL, "", en_us,
 436                    0xdeadbeef, 0xdeadbeef, E_INVALIDARG,0);
 437     test_names_ids(name_Italic, "Italic", NULL, "", en_us,
 438                    0xdeadbeef, 0xdeadbeef, E_INVALIDARG,0);
 439     test_names_ids(name_Foo, "Foo", NULL, "", en_us,
 440                    0xdeadbeef, 0xdeadbeef, E_INVALIDARG,0);
 441
 442     /* Crazy locale ID? */
 443     test_names_ids(name_Name, "Name", NULL, "", -1,
 444                    DISPID_FONT_NAME, 0, S_OK,1);
 445 }
 446
 447 static void test_Invoke(void)
 448 {
 449     IFontDisp *fontdisp;
 450     HRESULT hr;
 451     VARIANTARG vararg;
 452     DISPPARAMS dispparams;
 453     VARIANT varresult;
 454
 455     hr = pOleCreateFontIndirect(NULL, &IID_IFontDisp, (void **)&fontdisp);
 456     ok_ole_success(hr, "OleCreateFontIndirect");
 457
 458     V_VT(&vararg) = VT_BOOL;
 459     V_BOOL(&vararg) = VARIANT_FALSE;
 460     dispparams.cNamedArgs = 0;
 461     dispparams.rgdispidNamedArgs = NULL;
 462     dispparams.cArgs = 1;
 463     dispparams.rgvarg = &vararg;
 464     hr = IFontDisp_Invoke(fontdisp, DISPID_FONT_BOLD, &IID_IFontDisp, 0, DISPATCH_PROPERTYPUT, &dispparams, NULL, NULL, NULL);
 465     ok(hr == DISP_E_UNKNOWNINTERFACE, "IFontDisp_Invoke should have returned DISP_E_UNKNOWNINTERFACE instead of 0x%08x\n", hr);
 466
 467     dispparams.cArgs = 0;
 468     dispparams.rgvarg = NULL;
 469     hr = IFontDisp_Invoke(fontdisp, DISPID_FONT_BOLD, &IID_NULL, 0, DISPATCH_PROPERTYPUT, &dispparams, NULL, NULL, NULL);
 470     ok(hr == DISP_E_BADPARAMCOUNT, "IFontDisp_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
 471
 472     hr = IFontDisp_Invoke(fontdisp, DISPID_FONT_BOLD, &IID_NULL, 0, DISPATCH_PROPERTYPUT, NULL, NULL, NULL, NULL);
 473     ok(hr == DISP_E_PARAMNOTOPTIONAL, "IFontDisp_Invoke should have returned DISP_E_PARAMNOTOPTIONAL instead of 0x%08x\n", hr);
 474
 475     hr = IFontDisp_Invoke(fontdisp, DISPID_FONT_BOLD, &IID_NULL, 0, DISPATCH_PROPERTYGET, NULL, NULL, NULL, NULL);
 476     ok(hr == DISP_E_PARAMNOTOPTIONAL, "IFontDisp_Invoke should have returned DISP_E_PARAMNOTOPTIONAL instead of 0x%08x\n", hr);
 477
 478     hr = IFontDisp_Invoke(fontdisp, DISPID_FONT_BOLD, &IID_NULL, 0, DISPATCH_PROPERTYGET, NULL, &varresult, NULL, NULL);
 479     ok_ole_success(hr, "IFontDisp_Invoke");
 480
 481     hr = IFontDisp_Invoke(fontdisp, DISPID_FONT_BOLD, &IID_NULL, 0, DISPATCH_METHOD, NULL, &varresult, NULL, NULL);
 482     ok(hr == DISP_E_MEMBERNOTFOUND, "IFontDisp_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 483
 484     hr = IFontDisp_Invoke(fontdisp, 0xdeadbeef, &IID_NULL, 0, DISPATCH_PROPERTYGET, NULL, &varresult, NULL, NULL);
 485     ok(hr == DISP_E_MEMBERNOTFOUND, "IFontDisp_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 486
 487     dispparams.cArgs = 1;
 488     dispparams.rgvarg = &vararg;
 489     hr = IFontDisp_Invoke(fontdisp, DISPID_FONT_BOLD, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &varresult, NULL, NULL);
 490     ok_ole_success(hr, "IFontDisp_Invoke");
 491
 492     IFontDisp_Release(fontdisp);
 493 }
 494
 495 static void test_IsEqual(void)
 496 {
 497     FONTDESC fd;
 498     IFont* ifnt = NULL;
 499     IFont* ifnt2 = NULL;
 500     HRESULT hres;
 501
 502     /* Basic font description */
 503     fd.cbSizeofstruct = sizeof(FONTDESC);
 504     fd.lpstrName      = system_font;
 505     S(fd.cySize).Lo   = 100;
 506     S(fd.cySize).Hi   = 100;
 507     fd.sWeight        = 0;
 508     fd.sCharset       = 0;
 509     fd.fItalic        = 0;
 510     fd.fUnderline     = 0;
 511     fd.fStrikethrough = 0;
 512
 513     /* Create font */
 514     pOleCreateFontIndirect(&fd, &IID_IFont, (void **)&ifnt);
 515
 516     /* Test equal fonts */
 517     pOleCreateFontIndirect(&fd, &IID_IFont, (void **)&ifnt2);
 518     hres = IFont_IsEqual(ifnt,ifnt2);
 519     ok(hres == S_OK,
 520         "IFont_IsEqual: (EQUAL) Expected S_OK but got 0x%08x\n",hres);
 521     IFont_Release(ifnt2);
 522
 523     /* Check for bad pointer */
 524     hres = IFont_IsEqual(ifnt,NULL);
 525     ok(hres == E_POINTER,
 526         "IFont_IsEqual: (NULL) Expected 0x80004003 but got 0x%08x\n",hres);
 527
 528     /* Test strName */
 529     fd.lpstrName = arial_font;
 530     pOleCreateFontIndirect(&fd, &IID_IFont, (void **)&ifnt2);
 531     hres = IFont_IsEqual(ifnt,ifnt2);
 532     ok(hres == S_FALSE,
 533         "IFont_IsEqual: (strName) Expected S_FALSE but got 0x%08x\n",hres);
 534     fd.lpstrName = system_font;
 535     IFont_Release(ifnt2);
 536
 537     /* Test lo font size */
 538     S(fd.cySize).Lo = 10000;
 539     pOleCreateFontIndirect(&fd, &IID_IFont, (void **)&ifnt2);
 540     hres = IFont_IsEqual(ifnt,ifnt2);
 541     ok(hres == S_FALSE,
 542         "IFont_IsEqual: (Lo font size) Expected S_FALSE but got 0x%08x\n",hres);
 543     S(fd.cySize).Lo = 100;
 544     IFont_Release(ifnt2);
 545
 546     /* Test hi font size */
 547     S(fd.cySize).Hi = 10000;
 548     pOleCreateFontIndirect(&fd, &IID_IFont, (void **)&ifnt2);
 549     hres = IFont_IsEqual(ifnt,ifnt2);
 550     ok(hres == S_FALSE,
 551         "IFont_IsEqual: (Hi font size) Expected S_FALSE but got 0x%08x\n",hres);
 552     S(fd.cySize).Hi = 100;
 553     IFont_Release(ifnt2);
 554
 555     /* Test font weight  */
 556     fd.sWeight = 100;
 557     pOleCreateFontIndirect(&fd, &IID_IFont, (void **)&ifnt2);
 558     hres = IFont_IsEqual(ifnt,ifnt2);
 559     ok(hres == S_FALSE,
 560         "IFont_IsEqual: (Weight) Expected S_FALSE but got 0x%08x\n",hres);
 561     fd.sWeight = 0;
 562     IFont_Release(ifnt2);
 563
 564     /* Test charset */
 565     fd.sCharset = 1;
 566     pOleCreateFontIndirect(&fd, &IID_IFont, (void **)&ifnt2);
 567     hres = IFont_IsEqual(ifnt,ifnt2);
 568     ok(hres == S_FALSE,
 569         "IFont_IsEqual: (Charset) Expected S_FALSE but got 0x%08x\n",hres);
 570     fd.sCharset = 0;
 571     IFont_Release(ifnt2);
 572
 573     /* Test italic setting */
 574     fd.fItalic = 1;
 575     pOleCreateFontIndirect(&fd, &IID_IFont, (void **)&ifnt2);
 576     hres = IFont_IsEqual(ifnt,ifnt2);
 577     ok(hres == S_FALSE,
 578         "IFont_IsEqual: (Italic) Expected S_FALSE but got 0x%08x\n",hres);
 579     fd.fItalic = 0;
 580     IFont_Release(ifnt2);
 581
 582     /* Test underline setting */
 583     fd.fUnderline = 1;
 584     pOleCreateFontIndirect(&fd, &IID_IFont, (void **)&ifnt2);
 585     hres = IFont_IsEqual(ifnt,ifnt2);
 586     ok(hres == S_FALSE,
 587         "IFont_IsEqual: (Underline) Expected S_FALSE but got 0x%08x\n",hres);
 588     fd.fUnderline = 0;
 589     IFont_Release(ifnt2);
 590
 591     /* Test strikethrough setting */
 592     fd.fStrikethrough = 1;
 593     pOleCreateFontIndirect(&fd, &IID_IFont, (void **)&ifnt2);
 594     hres = IFont_IsEqual(ifnt,ifnt2);
 595     ok(hres == S_FALSE,
 596         "IFont_IsEqual: (Strikethrough) Expected S_FALSE but got 0x%08x\n",hres);
 597     fd.fStrikethrough = 0;
 598     IFont_Release(ifnt2);
 599
 600     /* Free IFont. */
 601     IFont_Release(ifnt);
 602 }
 603
 604 static void test_ReleaseHfont(void)
 605 {
 606     FONTDESC fd;
 607     LPVOID pvObj1 = NULL;
 608     LPVOID pvObj2 = NULL;
 609     IFont* ifnt1 = NULL;
 610     IFont* ifnt2 = NULL;
 611     HFONT hfnt1 = 0;
 612     HFONT hfnt2 = 0;
 613     HRESULT hres;
 614
 615     /* Basic font description */
 616     fd.cbSizeofstruct = sizeof(FONTDESC);
 617     fd.lpstrName      = system_font;
 618     S(fd.cySize).Lo   = 100;
 619     S(fd.cySize).Hi   = 100;
 620     fd.sWeight        = 0;
 621     fd.sCharset       = 0;
 622     fd.fItalic        = 0;
 623     fd.fUnderline     = 0;
 624     fd.fStrikethrough = 0;
 625
 626     /* Create HFONTs and IFONTs */
 627     pOleCreateFontIndirect(&fd, &IID_IFont, &pvObj1);
 628     ifnt1 = pvObj1;
 629     IFont_get_hFont(ifnt1,&hfnt1);
 630     fd.lpstrName = arial_font;
 631     pOleCreateFontIndirect(&fd, &IID_IFont, &pvObj2);
 632     ifnt2 = pvObj2;
 633     IFont_get_hFont(ifnt2,&hfnt2);
 634
 635     /* Try invalid HFONT */
 636     hres = IFont_ReleaseHfont(ifnt1,NULL);
 637     ok(hres == E_INVALIDARG,
 638         "IFont_ReleaseHfont: (Bad HFONT) Expected E_INVALIDARG but got 0x%08x\n",
 639         hres);
 640
 641     /* Try to add a bad HFONT */
 642     hres = IFont_ReleaseHfont(ifnt1,(HFONT)32);
 643     ok(hres == S_FALSE,
 644         "IFont_ReleaseHfont: (Bad HFONT) Expected S_FALSE but got 0x%08x\n",
 645         hres);
 646
 647     /* Release all refs */
 648     hres = IFont_ReleaseHfont(ifnt1,hfnt1);
 649     ok(hres == S_OK,
 650         "IFont_AddRefHfont: (Release ref) Expected S_OK but got 0x%08x\n",
 651         hres);
 652
 653     hres = IFont_ReleaseHfont(ifnt2,hfnt2);
 654     ok(hres == S_OK,
 655         "IFont_AddRefHfont: (Release ref) Expected S_OK but got 0x%08x\n",
 656         hres);
 657
 658     /* Check that both lists are empty */
 659     hres = IFont_ReleaseHfont(ifnt1,hfnt1);
 660     ok(hres == S_FALSE,
 661         "IFont_AddRefHfont: (Release ref) Expected S_FALSE but got 0x%08x\n",
 662         hres);
 663
 664     /* The list should be empty */
 665     hres = IFont_ReleaseHfont(ifnt2,hfnt2);
 666     ok(hres == S_FALSE,
 667         "IFont_AddRefHfont: (Release ref) Expected S_FALSE but got 0x%08x\n",
 668         hres);
 669
 670     IFont_Release(ifnt1);
 671     IFont_Release(ifnt2);
 672 }
 673
 674 static void test_AddRefHfont(void)
 675 {
 676     FONTDESC fd;
 677     IFont* ifnt1 = NULL;
 678     IFont* ifnt2 = NULL;
 679     IFont* ifnt3 = NULL;
 680     HFONT hfnt1 = 0;
 681     HFONT hfnt2 = 0;
 682     HFONT hfnt3 = 0;
 683     HRESULT hres;
 684
 685     /* Basic font description */
 686     fd.cbSizeofstruct = sizeof(FONTDESC);
 687     fd.lpstrName      = system_font;
 688     S(fd.cySize).Lo   = 100;
 689     S(fd.cySize).Hi   = 100;
 690     fd.sWeight        = 0;
 691     fd.sCharset       = 0;
 692     fd.fItalic        = 0;
 693     fd.fUnderline     = 0;
 694     fd.fStrikethrough = 0;
 695
 696     /* Create HFONTs and IFONTs */
 697     pOleCreateFontIndirect(&fd, &IID_IFont, (void **)&ifnt1);
 698     IFont_get_hFont(ifnt1,&hfnt1);
 699     fd.lpstrName = arial_font;
 700     pOleCreateFontIndirect(&fd, &IID_IFont, (void **)&ifnt2);
 701     IFont_get_hFont(ifnt2,&hfnt2);
 702
 703     /* Try invalid HFONT */
 704     hres = IFont_AddRefHfont(ifnt1,NULL);
 705     ok(hres == E_INVALIDARG,
 706         "IFont_AddRefHfont: (Bad HFONT) Expected E_INVALIDARG but got 0x%08x\n",
 707         hres);
 708
 709     /* Try to add a bad HFONT */
 710     hres = IFont_AddRefHfont(ifnt1,(HFONT)32);
 711     ok(hres == S_FALSE,
 712         "IFont_AddRefHfont: (Bad HFONT) Expected S_FALSE but got 0x%08x\n",
 713         hres);
 714
 715     /* Add simple IFONT HFONT pair */
 716     hres = IFont_AddRefHfont(ifnt1,hfnt1);
 717     ok(hres == S_OK,
 718         "IFont_AddRefHfont: (Add ref) Expected S_OK but got 0x%08x\n",
 719         hres);
 720
 721     /* IFONT and HFONT do not have to be the same (always looks at HFONT) */
 722     hres = IFont_AddRefHfont(ifnt2,hfnt1);
 723     ok(hres == S_OK,
 724         "IFont_AddRefHfont: (Add ref) Expected S_OK but got 0x%08x\n",
 725         hres);
 726
 727     /* Release all hfnt1 refs */
 728     hres = IFont_ReleaseHfont(ifnt1,hfnt1);
 729     ok(hres == S_OK,
 730         "IFont_AddRefHfont: (Release ref) Expected S_OK but got 0x%08x\n",
 731         hres);
 732
 733     hres = IFont_ReleaseHfont(ifnt1,hfnt1);
 734     ok(hres == S_OK,
 735         "IFont_AddRefHfont: (Release ref) Expected S_OK but got 0x%08x\n",
 736         hres);
 737
 738     hres = IFont_ReleaseHfont(ifnt1,hfnt1);
 739     ok(hres == S_OK,
 740         "IFont_AddRefHfont: (Release ref) Expected S_OK but got 0x%08x\n",
 741         hres);
 742
 743     /* Check if hfnt1 is empty */
 744     hres = IFont_ReleaseHfont(ifnt1,hfnt1);
 745     ok(hres == S_FALSE,
 746         "IFont_AddRefHfont: (Release ref) Expected S_FALSE but got 0x%08x\n",
 747         hres);
 748
 749     /* Release all hfnt2 refs */
 750     hres = IFont_ReleaseHfont(ifnt2,hfnt2);
 751     ok(hres == S_OK,
 752         "IFont_AddRefHfont: (Release ref) Expected S_OK but got 0x%08x\n",
 753         hres);
 754
 755     /* Check if hfnt2 is empty */
 756     hres = IFont_ReleaseHfont(ifnt2,hfnt2);
 757     ok(hres == S_FALSE,
 758         "IFont_AddRefHfont: (Release ref) Expected S_FALSE but got 0x%08x\n",
 759         hres);
 760
 761     /* Show that releasing an IFONT does not always release it from the HFONT cache. */
 762
 763     IFont_Release(ifnt1);
 764
 765     /* Add a reference for destroyed hfnt1 */
 766     hres = IFont_AddRefHfont(ifnt2,hfnt1);
 767     ok(hres == S_OK,
 768         "IFont_AddRefHfont: (Add ref) Expected S_OK but got 0x%08x\n",
 769         hres);
 770
 771     /* Decrement reference for destroyed hfnt1 */
 772     hres = IFont_ReleaseHfont(ifnt2,hfnt1);
 773     ok(hres == S_OK ||
 774        hres == S_FALSE, /* <= win2k */
 775         "IFont_AddRefHfont: (Release ref) Expected S_OK or S_FALSE but got 0x%08x\n",
 776         hres);
 777
 778     /* Shows that releasing all IFONT's does clear the HFONT cache. */
 779
 780     IFont_Release(ifnt2);
 781
 782     /* Need to make a new IFONT for testing */
 783     fd.fUnderline = 1;
 784     pOleCreateFontIndirect(&fd, &IID_IFont, (void **)&ifnt3);
 785     IFont_get_hFont(ifnt3,&hfnt3);
 786
 787     /* Add a reference for destroyed hfnt1 */
 788     hres = IFont_AddRefHfont(ifnt3,hfnt1);
 789     ok(hres == S_FALSE,
 790         "IFont_AddRefHfont: (Add ref) Expected S_OK but got 0x%08x\n",
 791         hres);
 792
 793     /* Decrement reference for destroyed hfnt1 */
 794     hres = IFont_ReleaseHfont(ifnt3,hfnt1);
 795     ok(hres == S_FALSE,
 796         "IFont_AddRefHfont: (Release ref) Expected S_OK but got 0x%08x\n",
 797         hres);
 798
 799     IFont_Release(ifnt3);
 800 }
 801
 802 static void test_returns(void)
 803 {
 804     IFont *pFont;
 805     FONTDESC fontdesc;
 806     HRESULT hr;
 807
 808     fontdesc.cbSizeofstruct = sizeof(fontdesc);
 809     fontdesc.lpstrName = MSSansSerif_font;
 810     fontdesc.cySize.int64 = 12 * 10000; /* 12 pt */
 811     fontdesc.sWeight = FW_NORMAL;
 812     fontdesc.sCharset = 0;
 813     fontdesc.fItalic = FALSE;
 814     fontdesc.fUnderline = FALSE;
 815     fontdesc.fStrikethrough = FALSE;
 816
 817     hr = pOleCreateFontIndirect(&fontdesc, &IID_IFont, (void **)&pFont);
 818     ok_ole_success(hr, "OleCreateFontIndirect");
 819
 820     hr = IFont_put_Name(pFont, NULL);
 821     ok(hr == CTL_E_INVALIDPROPERTYVALUE,
 822        "IFont::put_Name: Expected CTL_E_INVALIDPROPERTYVALUE got 0x%08x\n",
 823        hr);
 824
 825     hr = IFont_get_Name(pFont, NULL);
 826     ok(hr == E_POINTER,
 827        "IFont::get_Name: Expected E_POINTER got 0x%08x\n",
 828        hr);
 829
 830     hr = IFont_get_Size(pFont, NULL);
 831     ok(hr == E_POINTER,
 832        "IFont::get_Size: Expected E_POINTER got 0x%08x\n",
 833        hr);
 834
 835     hr = IFont_get_Bold(pFont, NULL);
 836     ok(hr == E_POINTER,
 837        "IFont::get_Bold: Expected E_POINTER got 0x%08x\n",
 838        hr);
 839
 840     IFont_Release(pFont);
 841 }
 842
 843 static void test_hfont_lifetime(void)
 844 {
 845     IFont *font, *font2;
 846     FONTDESC fontdesc;
 847     HRESULT hr;
 848     HFONT hfont, first_hfont = NULL;
 849     CY size;
 850     DWORD obj_type;
 851     int i;
 852
 853     fontdesc.cbSizeofstruct = sizeof(fontdesc);
 854     fontdesc.lpstrName = arial_font;
 855     fontdesc.cySize.int64 = 12 * 10000; /* 12 pt */
 856     fontdesc.sWeight = FW_NORMAL;
 857     fontdesc.sCharset = ANSI_CHARSET;
 858     fontdesc.fItalic = FALSE;
 859     fontdesc.fUnderline = FALSE;
 860     fontdesc.fStrikethrough = FALSE;
 861
 862     hr = pOleCreateFontIndirect(&fontdesc, &IID_IFont, (void **)&font);
 863     ok_ole_success(hr, "OleCreateFontIndirect");
 864
 865     hr = IFont_get_hFont(font, &hfont);
 866     ok_ole_success(hr, "get_hFont");
 867
 868     /* show that if the font is updated the old hfont is deleted when the
 869        new font is realized */
 870     for(i = 0; i < 100; i++)
 871     {
 872         HFONT last_hfont = hfont;
 873
 874         size.int64 = (i + 10) * 20000;
 875
 876         obj_type = GetObjectType(hfont);
 877         ok(obj_type == OBJ_FONT, "got obj type %d\n", obj_type);
 878
 879         hr = IFont_put_Size(font, size);
 880         ok_ole_success(hr, "put_Size");
 881
 882         /* put_Size doesn't cause the new font to be realized */
 883         obj_type = GetObjectType(last_hfont);
 884         ok(obj_type == OBJ_FONT, "got obj type %d\n", obj_type);
 885
 886         hr = IFont_get_hFont(font, &hfont);
 887         ok_ole_success(hr, "get_hFont");
 888
 889         obj_type = GetObjectType(last_hfont);
 890         ok(obj_type == 0, "%d: got obj type %d\n", i, obj_type);
 891     }
 892
 893     /* now show that if we take a reference on the hfont, it persists
 894        until the font object is released */
 895     for(i = 0; i < 100; i++)
 896     {
 897
 898         size.int64 = (i + 10) * 20000;
 899
 900         obj_type = GetObjectType(hfont);
 901         ok(obj_type == OBJ_FONT, "got obj type %d\n", obj_type);
 902
 903         hr = IFont_put_Size(font, size);
 904         ok_ole_success(hr, "put_Size");
 905
 906         hr = IFont_get_hFont(font, &hfont);
 907         ok_ole_success(hr, "get_hFont");
 908
 909         hr = IFont_AddRefHfont(font, hfont);
 910         ok_ole_success(hr, "AddRefHfont");
 911
 912         if(i == 0) first_hfont = hfont;
 913         obj_type = GetObjectType(first_hfont);
 914         ok(obj_type == OBJ_FONT, "got obj type %d\n", obj_type);
 915     }
 916
 917     IFont_Release(font);
 918
 919     obj_type = GetObjectType(first_hfont);
 920     ok(obj_type == 0, "got obj type %d\n", obj_type);
 921
 922     /* An AddRefHfont followed by a ReleaseHfont means the font doesn't not persist
 923        through re-realization */
 924
 925     hr = pOleCreateFontIndirect(&fontdesc, &IID_IFont, (void **)&font);
 926     ok_ole_success(hr, "OleCreateFontIndirect");
 927
 928     hr = IFont_get_hFont(font, &hfont);
 929     ok_ole_success(hr, "get_hFont");
 930
 931     for(i = 0; i < 100; i++)
 932     {
 933         HFONT last_hfont = hfont;
 934
 935         size.int64 = (i + 10) * 20000;
 936
 937         obj_type = GetObjectType(hfont);
 938         ok(obj_type == OBJ_FONT, "got obj type %d\n", obj_type);
 939
 940         hr = IFont_put_Size(font, size);
 941         ok_ole_success(hr, "put_Size");
 942
 943         /* put_Size doesn't cause the new font to be realized */
 944         obj_type = GetObjectType(last_hfont);
 945         ok(obj_type == OBJ_FONT, "got obj type %d\n", obj_type);
 946
 947         hr = IFont_get_hFont(font, &hfont);
 948         ok_ole_success(hr, "get_hFont");
 949
 950         hr = IFont_AddRefHfont(font, hfont);
 951         ok_ole_success(hr, "AddRefHfont");
 952
 953         hr = IFont_ReleaseHfont(font, hfont);
 954         ok_ole_success(hr, "ReleaseHfont");
 955
 956         obj_type = GetObjectType(last_hfont);
 957         ok(obj_type == 0, "%d: got obj type %d\n", i, obj_type);
 958     }
 959
 960     /* Interestingly if we release a nonexistent reference on the hfont,
 961      * it persists until the font object is released
 962      */
 963     for(i = 0; i < 100; i++)
 964     {
 965         size.int64 = (i + 10) * 20000;
 966
 967         obj_type = GetObjectType(hfont);
 968         ok(obj_type == OBJ_FONT, "got obj type %d\n", obj_type);
 969
 970         hr = IFont_put_Size(font, size);
 971         ok_ole_success(hr, "put_Size");
 972
 973         hr = IFont_get_hFont(font, &hfont);
 974         ok_ole_success(hr, "get_hFont");
 975
 976         hr = IFont_ReleaseHfont(font, hfont);
 977         ok_ole_success(hr, "ReleaseHfont");
 978
 979         if(i == 0) first_hfont = hfont;
 980         obj_type = GetObjectType(first_hfont);
 981         ok(obj_type == OBJ_FONT, "got obj type %d\n", obj_type);
 982     }
 983
 984     IFont_Release(font);
 985
 986     obj_type = GetObjectType(first_hfont);
 987     ok(obj_type == 0, "got obj type %d\n", obj_type);
 988
 989     /* If we take two internal references on a hfont then we can release
 990        it twice.  So it looks like there's a total reference count
 991        that includes internal and external references */
 992
 993     hr = pOleCreateFontIndirect(&fontdesc, &IID_IFont, (void **)&font);
 994     ok_ole_success(hr, "OleCreateFontIndirect");
 995     hr = pOleCreateFontIndirect(&fontdesc, &IID_IFont, (void **)&font2);
 996     ok_ole_success(hr, "OleCreateFontIndirect");
 997
 998     hr = IFont_get_hFont(font, &hfont);
 999     ok_ole_success(hr, "get_hFont");
1000     hr = IFont_get_hFont(font2, &first_hfont);
1001     ok_ole_success(hr, "get_hFont");
1002 todo_wine
1003     ok(hfont == first_hfont, "fonts differ\n");
1004     hr = IFont_ReleaseHfont(font, hfont);
1005     ok(hr == S_OK, "got %08x\n", hr);
1006     hr = IFont_ReleaseHfont(font, hfont);
1007 todo_wine
1008     ok(hr == S_OK, "got %08x\n", hr);
1009     hr = IFont_ReleaseHfont(font, hfont);
1010     ok(hr == S_FALSE, "got %08x\n", hr);
1011
1012     obj_type = GetObjectType(hfont);
1013     ok(obj_type == OBJ_FONT, "got obj type %d\n", obj_type);
1014
1015     IFont_Release(font);
1016
1017     obj_type = GetObjectType(hfont);
1018     ok(obj_type == OBJ_FONT, "got obj type %d\n", obj_type);
1019
1020     IFont_Release(font2);
1021
1022     obj_type = GetObjectType(hfont);
1023     ok(obj_type == 0, "got obj type %d\n", obj_type);
1024 }
1025
1026 static void test_realization(void)
1027 {
1028     IFont *font;
1029     FONTDESC fontdesc;
1030     HRESULT hr;
1031     BSTR name;
1032     SHORT cs;
1033
1034     /* Try to create a symbol only font (marlett) with charset
1035        set to ANSI.  This will result in another, ANSI, font
1036        being selected */
1037     fontdesc.cbSizeofstruct = sizeof(fontdesc);
1038     fontdesc.lpstrName = marlett_font;
1039     fontdesc.cySize.int64 = 12 * 10000; /* 12 pt */
1040     fontdesc.sWeight = FW_NORMAL;
1041     fontdesc.sCharset = ANSI_CHARSET;
1042     fontdesc.fItalic = FALSE;
1043     fontdesc.fUnderline = FALSE;
1044     fontdesc.fStrikethrough = FALSE;
1045
1046     hr = pOleCreateFontIndirect(&fontdesc, &IID_IFont, (void **)&font);
1047     ok_ole_success(hr, "OleCreateFontIndirect");
1048
1049     hr = IFont_get_Charset(font, &cs);
1050     ok_ole_success(hr, "get_Charset");
1051     ok(cs == ANSI_CHARSET, "got charset %d\n", cs);
1052
1053     IFont_Release(font);
1054
1055     /* Now create an ANSI font and change the name to marlett */
1056
1057     fontdesc.lpstrName = arial_font;
1058
1059     hr = pOleCreateFontIndirect(&fontdesc, &IID_IFont, (void **)&font);
1060     ok_ole_success(hr, "OleCreateFontIndirect");
1061
1062     hr = IFont_get_Charset(font, &cs);
1063     ok_ole_success(hr, "get_Charset");
1064     ok(cs == ANSI_CHARSET, "got charset %d\n", cs);
1065
1066     name = SysAllocString(marlett_font);
1067     hr = IFont_put_Name(font, name);
1068     ok_ole_success(hr, "put_Name");
1069     SysFreeString(name);
1070
1071     hr = IFont_get_Name(font, &name);
1072     ok_ole_success(hr, "get_Name");
1073     ok(!lstrcmpiW(name, marlett_font), "got name %s\n", wine_dbgstr_w(name));
1074     SysFreeString(name);
1075
1076     hr = IFont_get_Charset(font, &cs);
1077     ok_ole_success(hr, "get_Charset");
1078     ok(cs == SYMBOL_CHARSET, "got charset %d\n", cs);
1079
1080     IFont_Release(font);
1081 }
1082
1083 START_TEST(olefont)
1084 {
1085         hOleaut32 = GetModuleHandleA("oleaut32.dll");
1086         pOleCreateFontIndirect = (void*)GetProcAddress(hOleaut32, "OleCreateFontIndirect");
1087         if (!pOleCreateFontIndirect)
1088         {
1089             win_skip("OleCreateFontIndirect not available\n");
1090             return;
1091         }
1092
1093         test_QueryInterface();
1094         test_type_info();
1095
1096         /* Test various size operations and conversions. */
1097         /* Add more as needed. */
1098         if (0) /* FIXME: failing tests */
1099         {
1100             test_ifont_sizes(180000, 0, 72, 2540, -18, "default");
1101             test_ifont_sizes(180000, 0, 144, 2540, -36, "ratio1");              /* change ratio */
1102             test_ifont_sizes(180000, 0, 72, 1270, -36, "ratio2");               /* 2nd part of ratio */
1103
1104             /* These depend on details of how IFont rounds sizes internally. */
1105             test_ifont_sizes(0, 0, 72, 2540, 0, "zero size");          /* zero size */
1106             test_ifont_sizes(186000, 0, 72, 2540, -19, "rounding");   /* test rounding */
1107         }
1108
1109         test_font_events_disp();
1110         test_GetIDsOfNames();
1111         test_Invoke();
1112         test_IsEqual();
1113         test_ReleaseHfont();
1114         test_AddRefHfont();
1115         test_returns();
1116         test_hfont_lifetime();
1117         test_realization();
1118 }