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

   1 /*
   2  * Tests for usp10 dll
   3  *
   4  * Copyright 2006 Jeff Latimer
   5  * Copyright 2006 Hans Leidekker
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  * Notes:
  22  * Uniscribe allows for processing of complex scripts such as joining
  23  * and filtering characters and bi-directional text with custom line breaks.
  24  */
  25
  26 #include <assert.h>
  27 #include <stdio.h>
  28
  29 #include <wine/test.h>
  30 #include <winbase.h>
  31 #include <wingdi.h>
  32 #include <winuser.h>
  33 #include <winerror.h>
  34 #include <winnls.h>
  35 #include <usp10.h>
  36
  37 static void test_ScriptItemIzeShapePlace(HDC hdc, unsigned short pwOutGlyphs[256])
  38 {
  39     HRESULT         hr;
  40     int             iMaxProps;
  41     const SCRIPT_PROPERTIES **ppSp;
  42
  43     int             cInChars;
  44     int             cMaxItems;
  45     SCRIPT_ITEM     pItem[255];
  46     int             pcItems;
  47     WCHAR           TestItem1[] = {'T', 'e', 's', 't', 'a', 0};
  48     WCHAR           TestItem2[] = {'T', 'e', 's', 't', 'b', 0};
  49     WCHAR           TestItem3[] = {'T', 'e', 's', 't', 'c',' ','1','2','3',' ',' ','e','n','d',0};
  50     WCHAR           TestItem4[] = {'T', 'e', 's', 't', 'c',' ',0x0684,0x0694,0x06a4,' ',' ','e','n','d',0};
  51     WCHAR           TestItem5[] = {0x0684,'T','e','s','t','c',' ',0x0684,0x0694,0x06a4,' ',' ','e','n','d',0};
  52
  53     SCRIPT_CACHE    psc;
  54     int             cChars;
  55     int             cMaxGlyphs;
  56     unsigned short  pwOutGlyphs1[256];
  57     unsigned short  pwOutGlyphs2[256];
  58     unsigned short  pwLogClust[256];
  59     SCRIPT_VISATTR  psva[256];
  60     int             pcGlyphs;
  61     int             piAdvance[256];
  62     GOFFSET         pGoffset[256];
  63     ABC             pABC[256];
  64     int             cnt;
  65
  66     /* Start testing usp10 functions                                                         */
  67     /* This test determines that the pointer returned by ScriptGetProperties is valid
  68      * by checking a known value in the table                                                */
  69     hr = ScriptGetProperties(&ppSp, &iMaxProps);
  70     trace("number of script properties %d\n", iMaxProps);
  71     ok (iMaxProps > 0, "Number of scripts returned should not be 0\n");
  72     if  (iMaxProps > 0)
  73          ok( ppSp[5]->langid == 9, "Langid[5] not = to 9\n"); /* Check a known value to ensure   */
  74                                                               /* ptrs work                       */
  75
  76
  77     /* This set of tests are to check that the various edits in ScriptIemize work           */
  78     cInChars = 5;                                        /* Length of test without NULL     */
  79     cMaxItems = 1;                                       /* Check threshold value           */
  80     hr = ScriptItemize(TestItem1, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
  81     ok (hr == E_INVALIDARG, "ScriptItemize should return E_INVALIDARG if cMaxItems < 2.  Was %d\n",
  82         cMaxItems);
  83     cInChars = 5;
  84     cMaxItems = 255;
  85     hr = ScriptItemize(NULL, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
  86     ok (hr == E_INVALIDARG, "ScriptItemize should return E_INVALIDARG if pwcInChars is NULL\n");
  87
  88     cInChars = 5;
  89     cMaxItems = 255;
  90     hr = ScriptItemize(TestItem1, 0, cMaxItems, NULL, NULL, pItem, &pcItems);
  91     ok (hr == E_INVALIDARG, "ScriptItemize should return E_INVALIDARG if cInChars is 0\n");
  92
  93     cInChars = 5;
  94     cMaxItems = 255;
  95     hr = ScriptItemize(TestItem1, cInChars, cMaxItems, NULL, NULL, NULL, &pcItems);
  96     ok (hr == E_INVALIDARG, "ScriptItemize should return E_INVALIDARG if pItems is NULL\n");
  97
  98     /* This is a valid test that will cause parsing to take place                             */
  99     cInChars = 5;
 100     cMaxItems = 255;
 101     hr = ScriptItemize(TestItem1, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
 102     ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
 103     /*  This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
 104      *  returned.                                                                             */
 105     ok (pcItems > 0, "The number of SCRIPT_ITEMS should be greater than 0\n");
 106     if (pcItems > 0)
 107         ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == cInChars,
 108             "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
 109             pItem[0].iCharPos, cInChars, pItem[1].iCharPos);
 110
 111     /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue
 112      * ie. ScriptItemize has succeeded and that pItem has been set                            */
 113     cInChars = 5;
 114     cMaxItems = 255;
 115     if (hr == 0) {
 116         psc = NULL;                                   /* must be null on first call           */
 117         cChars = cInChars;
 118         cMaxGlyphs = cInChars;
 119         hr = ScriptShape(NULL, &psc, TestItem1, cChars,
 120                          cMaxGlyphs, &pItem[0].a,
 121                          pwOutGlyphs1, pwLogClust, psva, &pcGlyphs);
 122         ok (hr == E_PENDING, "If psc is NULL (%08x) the E_PENDING should be returned\n", hr);
 123         cMaxGlyphs = 4;
 124         hr = ScriptShape(hdc, &psc, TestItem1, cChars,
 125                          cMaxGlyphs, &pItem[0].a,
 126                          pwOutGlyphs1, pwLogClust, psva, &pcGlyphs);
 127         ok (hr == E_OUTOFMEMORY, "If not enough output area cChars (%d) is > than CMaxGlyphs "
 128                                  "(%d) but not E_OUTOFMEMORY\n",
 129                                  cChars, cMaxGlyphs);
 130         cMaxGlyphs = 256;
 131         hr = ScriptShape(hdc, &psc, TestItem1, cChars,
 132                          cMaxGlyphs, &pItem[0].a,
 133                          pwOutGlyphs1, pwLogClust, psva, &pcGlyphs);
 134         ok (hr == 0, "ScriptShape should return 0 not (%08x)\n", hr);
 135         ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
 136         ok (pcGlyphs == cChars, "Chars in (%d) should equal Glyphs out (%d)\n", cChars, pcGlyphs);
 137         if (hr ==0) {
 138             hr = ScriptPlace(hdc, &psc, pwOutGlyphs1, pcGlyphs, psva, &pItem[0].a, piAdvance,
 139                              pGoffset, pABC);
 140             ok (hr == 0, "ScriptPlace should return 0 not (%08x)\n", hr);
 141             hr = ScriptPlace(NULL, &psc, pwOutGlyphs1, pcGlyphs, psva, &pItem[0].a, piAdvance,
 142                              pGoffset, pABC);
 143             ok (hr == 0, "ScriptPlace should return 0 not (%08x)\n", hr);
 144             for (cnt=0; cnt < pcGlyphs; cnt++)
 145                 pwOutGlyphs[cnt] = pwOutGlyphs1[cnt];                 /* Send to next function */
 146         }
 147
 148         /* This test will check to make sure that SCRIPT_CACHE is reused and that not translation   *
 149          * takes place if fNoGlyphIndex is set.                                                     */
 150
 151         cInChars = 5;
 152         cMaxItems = 255;
 153         hr = ScriptItemize(TestItem2, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
 154         ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
 155         /*  This test is for the intertrim operation of ScriptItemize where only one SCRIPT_ITEM is *
 156          *  returned.                                                                               */
 157         ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == cInChars,
 158                             "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
 159                              pItem[0].iCharPos, cInChars, pItem[1].iCharPos);
 160         /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue                    */
 161         if (hr == 0) {
 162              cChars = cInChars;
 163              cMaxGlyphs = 256;
 164              pItem[0].a.fNoGlyphIndex = 1;                /* say no translate                     */
 165              hr = ScriptShape(NULL, &psc, TestItem2, cChars,
 166                               cMaxGlyphs, &pItem[0].a,
 167                               pwOutGlyphs2, pwLogClust, psva, &pcGlyphs);
 168              ok (hr != E_PENDING, "If psc should not be NULL (%08x) and the E_PENDING should be returned\n", hr);
 169              ok (hr == 0, "ScriptShape should return 0 not (%08x)\n", hr);
 170              ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
 171              ok (pcGlyphs == cChars, "Chars in (%d) should equal Glyphs out (%d)\n", cChars, pcGlyphs);
 172              for (cnt=0; cnt < cChars && TestItem2[cnt] == pwOutGlyphs2[cnt]; cnt++) {}
 173              ok (cnt == cChars, "Translation to place when told not to. WCHAR %d - %04x != %04x\n",
 174                            cnt, TestItem2[cnt], pwOutGlyphs2[cnt]);
 175              if (hr ==0) {
 176                  hr = ScriptPlace(hdc, &psc, pwOutGlyphs2, pcGlyphs, psva, &pItem[0].a, piAdvance,
 177                                   pGoffset, pABC);
 178                  ok (hr == 0, "ScriptPlace should return 0 not (%08x)\n", hr);
 179              }
 180         }
 181         hr = ScriptFreeCache( &psc);
 182         ok (!psc, "psc is not null after ScriptFreeCache\n");
 183
 184     }
 185
 186     /* This is a valid test that will cause parsing to take place and create 3 script_items   */
 187     cInChars = (sizeof(TestItem3)/2)-1;
 188     cMaxItems = 255;
 189     hr = ScriptItemize(TestItem3, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
 190     ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
 191     if  (hr == 0)
 192         {
 193         ok (pcItems == 3, "The number of SCRIPT_ITEMS should be 3 not %d\n", pcItems);
 194         if (pcItems > 2)
 195         {
 196             ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == 6,
 197                 "Start pos [0] not = 0 (%d) or end pos [1] not = %d\n",
 198                 pItem[0].iCharPos, pItem[1].iCharPos);
 199             ok (pItem[1].iCharPos == 6 && pItem[2].iCharPos == 11,
 200                 "Start pos [1] not = 6 (%d) or end pos [2] not = 11 (%d)\n",
 201                 pItem[1].iCharPos, pItem[2].iCharPos);
 202             ok (pItem[2].iCharPos == 11 && pItem[3].iCharPos == cInChars,
 203                 "Start pos [2] not = 11 (%d) or end [3] pos not = 14 (%d), cInChars = %d\n",
 204                 pItem[2].iCharPos, pItem[3].iCharPos, cInChars);
 205         }
 206         hr = ScriptFreeCache( &psc);
 207         ok (!psc, "psc is not null after ScriptFreeCache\n");
 208     }
 209
 210     /* This is a valid test that will cause parsing to take place and create 3 script_items   */
 211     cInChars = (sizeof(TestItem4)/2)-1;
 212     cMaxItems = 255;
 213     hr = ScriptItemize(TestItem4, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
 214     ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
 215     if  (hr == 0)
 216         {
 217         ok (pcItems == 3, "The number of SCRIPT_ITEMS should be 3 not %d\n", pcItems);
 218         if (pcItems > 2)
 219         {
 220             ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == 6,
 221                 "Start pos [0] not = 0 (%d) or end pos [1] not = %d\n",
 222                 pItem[0].iCharPos, pItem[1].iCharPos);
 223             ok (pItem[1].iCharPos == 6 && pItem[2].iCharPos == 11,
 224                 "Start pos [1] not = 6 (%d) or end pos [2] not = 11 (%d)\n",
 225                 pItem[1].iCharPos, pItem[2].iCharPos);
 226             ok (pItem[2].iCharPos == 11 && pItem[3].iCharPos == cInChars,
 227                 "Start pos [2] not = 11 (%d) or end [3] pos not = 14 (%d), cInChars = %d\n",
 228                 pItem[2].iCharPos, pItem[3].iCharPos, cInChars);
 229         }
 230         hr = ScriptFreeCache( &psc);
 231         ok (!psc, "psc is not null after ScriptFreeCache\n");
 232     }
 233
 234     /*
 235      * This test is for when the first unicode character requires bidi support
 236      */
 237     cInChars = (sizeof(TestItem5)-1)/sizeof(WCHAR);
 238     hr = ScriptItemize(TestItem5, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
 239     ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
 240     ok (pcItems == 4, "There should have been 4 items, found %d\n", pcItems);
 241     ok (pItem[0].a.s.uBidiLevel == 1, "The first character should have been bidi=1 not %d\n",
 242                                        pItem[0].a.s.uBidiLevel);
 243 }
 244
 245 static void test_ScriptGetCMap(HDC hdc, unsigned short pwOutGlyphs[256])
 246 {
 247     HRESULT         hr;
 248     SCRIPT_CACHE    psc = NULL;
 249     int             cInChars;
 250     int             cChars;
 251     unsigned short  pwOutGlyphs3[256];
 252     WCHAR           TestItem1[] = {'T', 'e', 's', 't', 'a', 0};
 253     DWORD           dwFlags;
 254     int             cnt;
 255
 256     /*  Check to make sure that SCRIPT_CACHE gets allocated ok                     */
 257     dwFlags = 0;
 258     cInChars = cChars = 5;
 259     /* Some sanity checks for ScriptGetCMap */
 260
 261     hr = ScriptGetCMap(NULL, NULL, NULL, 0, 0, NULL);
 262     ok( hr == E_INVALIDARG, "(NULL,NULL,NULL,0,0,NULL), "
 263                             "expected E_INVALIDARG, got %08x\n", hr);
 264
 265     hr = ScriptGetCMap(NULL, NULL, TestItem1, cInChars, dwFlags, pwOutGlyphs3);
 266     ok( hr == E_INVALIDARG, "(NULL,NULL,TestItem1, cInChars, dwFlags, pwOutGlyphs3), "
 267                             "expected E_INVALIDARG, got %08x\n", hr);
 268
 269     /* Set psc to NULL, to be able to check if a pointer is returned in psc */
 270     psc = NULL;
 271     hr = ScriptGetCMap(NULL, &psc, NULL, 0, 0, NULL);
 272     ok( hr == E_PENDING, "(NULL,&psc,NULL,0,0NULL), expected E_PENDING, "
 273                          "got %08x\n", hr);
 274     ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
 275
 276     /* Set psc to NULL but add hdc, to be able to check if a pointer is returned in psc */
 277     psc = NULL;
 278     hr = ScriptGetCMap(hdc, &psc, NULL, 0, 0, NULL);
 279     ok( hr == S_OK, "ScriptGetCMap(NULL,&psc,NULL,0,0,NULL), expected S_OK, "
 280                     "got %08x\n", hr);
 281     ok( psc != NULL, "ScritpGetCMap expected psc to be not NULL\n");
 282     ScriptFreeCache( &psc);
 283
 284     /* Set psc to NULL, to be able to check if a pointer is returned in psc */
 285     psc = NULL;
 286     hr = ScriptGetCMap(NULL, &psc, TestItem1, cInChars, dwFlags, pwOutGlyphs3);
 287     ok( hr == E_PENDING, "(NULL,&psc,), expected E_PENDING, got %08x\n", hr);
 288     ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
 289     /*  Check to see if the results are the same as those returned by ScriptShape  */
 290     hr = ScriptGetCMap(hdc, &psc, TestItem1, cInChars, dwFlags, pwOutGlyphs3);
 291     ok (hr == 0, "ScriptGetCMap should return 0 not (%08x)\n", hr);
 292     ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
 293     for (cnt=0; cnt < cChars && pwOutGlyphs[cnt] == pwOutGlyphs3[cnt]; cnt++) {}
 294     ok (cnt == cInChars, "Translation not correct. WCHAR %d - %04x != %04x\n",
 295                          cnt, pwOutGlyphs[cnt], pwOutGlyphs3[cnt]);
 296
 297     hr = ScriptFreeCache( &psc);
 298     ok (!psc, "psc is not null after ScriptFreeCache\n");
 299
 300 }
 301
 302 static void test_ScriptGetFontProperties(HDC hdc)
 303 {
 304     HRESULT         hr;
 305     SCRIPT_CACHE    psc,old_psc;
 306     SCRIPT_FONTPROPERTIES sfp;
 307
 308     /* Some sanity checks for ScriptGetFontProperties */
 309
 310     hr = ScriptGetFontProperties(NULL,NULL,NULL);
 311     ok( hr == E_INVALIDARG, "(NULL,NULL,NULL), expected E_INVALIDARG, got %08x\n", hr);
 312
 313     hr = ScriptGetFontProperties(NULL,NULL,&sfp);
 314     ok( hr == E_INVALIDARG, "(NULL,NULL,&sfp), expected E_INVALIDARG, got %08x\n", hr);
 315
 316     /* Set psc to NULL, to be able to check if a pointer is returned in psc */
 317     psc = NULL;
 318     hr = ScriptGetFontProperties(NULL,&psc,NULL);
 319     ok( hr == E_INVALIDARG, "(NULL,&psc,NULL), expected E_INVALIDARG, got %08x\n", hr);
 320     ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
 321
 322     /* Set psc to NULL, to be able to check if a pointer is returned in psc */
 323     psc = NULL;
 324     hr = ScriptGetFontProperties(NULL,&psc,&sfp);
 325     ok( hr == E_PENDING, "(NULL,&psc,&sfp), expected E_PENDING, got %08x\n", hr);
 326     ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
 327
 328     hr = ScriptGetFontProperties(hdc,NULL,NULL);
 329     ok( hr == E_INVALIDARG, "(hdc,NULL,NULL), expected E_INVALIDARG, got %08x\n", hr);
 330
 331     hr = ScriptGetFontProperties(hdc,NULL,&sfp);
 332     ok( hr == E_INVALIDARG, "(hdc,NULL,&sfp), expected E_INVALIDARG, got %08x\n", hr);
 333
 334     /* Set psc to NULL, to be able to check if a pointer is returned in psc */
 335     psc = NULL;
 336     hr = ScriptGetFontProperties(hdc,&psc,NULL);
 337     ok( hr == E_INVALIDARG, "(hdc,&psc,NULL), expected E_INVALIDARG, got %08x\n", hr);
 338     ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
 339
 340     /* Pass an invalid sfp */
 341     psc = NULL;
 342     sfp.cBytes = sizeof(SCRIPT_FONTPROPERTIES) - 1;
 343     hr = ScriptGetFontProperties(hdc,&psc,&sfp);
 344     ok( hr == E_INVALIDARG, "(hdc,&psc,&sfp) invalid, expected E_INVALIDARG, got %08x\n", hr);
 345     ok( psc != NULL, "Expected a pointer in psc, got NULL\n");
 346     ScriptFreeCache(&psc);
 347     ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
 348
 349     /* Give it the correct cBytes, we don't care about what's coming back */
 350     sfp.cBytes = sizeof(SCRIPT_FONTPROPERTIES);
 351     psc = NULL;
 352     hr = ScriptGetFontProperties(hdc,&psc,&sfp);
 353     ok( hr == S_OK, "(hdc,&psc,&sfp) partly initialized, expected S_OK, got %08x\n", hr);
 354     ok( psc != NULL, "Expected a pointer in psc, got NULL\n");
 355
 356     /* Save the psc pointer */
 357     old_psc = psc;
 358     /* Now a NULL hdc again */
 359     hr = ScriptGetFontProperties(NULL,&psc,&sfp);
 360     ok( hr == S_OK, "(NULL,&psc,&sfp), expected S_OK, got %08x\n", hr);
 361     ok( psc == old_psc, "Expected psc not to be changed, was %p is now %p\n", old_psc, psc);
 362     ScriptFreeCache(&psc);
 363     ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
 364 }
 365
 366 static void test_ScriptTextOut(HDC hdc)
 367 {
 368     HRESULT         hr;
 369
 370     int             cInChars;
 371     int             cMaxItems;
 372     SCRIPT_ITEM     pItem[255];
 373     int             pcItems;
 374     WCHAR           TestItem1[] = {'T', 'e', 's', 't', 'a', 0};
 375
 376     SCRIPT_CACHE    psc;
 377     int             cChars;
 378     int             cMaxGlyphs;
 379     unsigned short  pwOutGlyphs1[256];
 380     WORD            pwLogClust[256];
 381     SCRIPT_VISATTR  psva[256];
 382     int             pcGlyphs;
 383     int             piAdvance[256];
 384     GOFFSET         pGoffset[256];
 385     ABC             pABC[256];
 386     RECT            rect;
 387     int             piX;
 388     int             iCP = 1;
 389     BOOL            fTrailing = FALSE;
 390     SCRIPT_LOGATTR  *psla;
 391     SCRIPT_LOGATTR  sla[256];
 392
 393     /* This is a valid test that will cause parsing to take place                             */
 394     cInChars = 5;
 395     cMaxItems = 255;
 396     hr = ScriptItemize(TestItem1, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
 397     ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
 398     /*  This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
 399      *  returned.                                                                             */
 400     ok (pcItems > 0, "The number of SCRIPT_ITEMS should be greater than 0\n");
 401     if (pcItems > 0)
 402         ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == cInChars,
 403             "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
 404             pItem[0].iCharPos, cInChars, pItem[1].iCharPos);
 405
 406     /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue
 407      * ie. ScriptItemize has succeeded and that pItem has been set                            */
 408     cInChars = 5;
 409     cMaxItems = 255;
 410     if (hr == 0) {
 411         psc = NULL;                                   /* must be null on first call           */
 412         cChars = cInChars;
 413         cMaxGlyphs = cInChars;
 414         cMaxGlyphs = 256;
 415         hr = ScriptShape(hdc, &psc, TestItem1, cChars,
 416                          cMaxGlyphs, &pItem[0].a,
 417                          pwOutGlyphs1, pwLogClust, psva, &pcGlyphs);
 418         ok (hr == 0, "ScriptShape should return 0 not (%08x)\n", hr);
 419         ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
 420         ok (pcGlyphs == cChars, "Chars in (%d) should equal Glyphs out (%d)\n", cChars, pcGlyphs);
 421         if (hr ==0) {
 422             /* Note hdc is needed as glyph info is not yet in psc                  */
 423             hr = ScriptPlace(hdc, &psc, pwOutGlyphs1, pcGlyphs, psva, &pItem[0].a, piAdvance,
 424                              pGoffset, pABC);
 425             ok (hr == 0, "Should return 0 not (%08x)\n", hr);
 426             ScriptFreeCache(&psc);              /* Get rid of psc for next test set */
 427             ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
 428
 429             hr = ScriptTextOut(NULL, NULL, 0, 0, 0, NULL, NULL, NULL, 0, NULL, 0, NULL, NULL, NULL);
 430             ok (hr == E_INVALIDARG, "Should return 0 not (%08x)\n", hr);
 431
 432             hr = ScriptTextOut(NULL, NULL, 0, 0, 0, NULL, &pItem[0].a, NULL, 0, pwOutGlyphs1, pcGlyphs,
 433                                piAdvance, NULL, pGoffset);
 434             ok( hr == E_INVALIDARG, "(NULL,NULL,TestItem1, cInChars, dwFlags, pwOutGlyphs3), "
 435                                     "expected E_INVALIDARG, got %08x\n", hr);
 436
 437             /* Set psc to NULL, to be able to check if a pointer is returned in psc */
 438             psc = NULL;
 439             hr = ScriptTextOut(NULL, &psc, 0, 0, 0, NULL, NULL, NULL, 0, NULL, 0,
 440                                NULL, NULL, NULL);
 441             ok( hr == E_INVALIDARG, "(NULL,&psc,NULL,0,0,0,NULL,), expected E_INVALIDARG, "
 442                                     "got %08x\n", hr);
 443             ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
 444
 445             /* Set psc to NULL, to be able to check if a pointer is returned in psc
 446              * hdc is required for this one rather than the usual optional          */
 447             psc = NULL;
 448             hr = ScriptTextOut(NULL, &psc, 0, 0, 0, NULL, &pItem[0].a, NULL, 0, pwOutGlyphs1, pcGlyphs,
 449                                piAdvance, NULL, pGoffset);
 450             ok( hr == E_INVALIDARG, "(NULL,&psc,), expected E_INVALIDARG, got %08x\n", hr);
 451             ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
 452
 453             /* Set that is gets a psc and that returns 0 status */
 454             hr = ScriptTextOut(hdc, &psc, 0, 0, 0, NULL, &pItem[0].a, NULL, 0, pwOutGlyphs1, pcGlyphs,
 455                                piAdvance, NULL, pGoffset);
 456             ok (hr == 0, "ScriptTextOut should return 0 not (%08x)\n", hr);
 457             ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
 458
 459             /* Test Rect Rgn is acceptable */
 460             rect.top = 10;
 461             rect.bottom = 20;
 462             rect.left = 10;
 463             rect.right = 40;
 464             hr = ScriptTextOut(hdc, &psc, 0, 0, 0, &rect, &pItem[0].a, NULL, 0, pwOutGlyphs1, pcGlyphs,
 465                                piAdvance, NULL, pGoffset);
 466             ok (hr == 0, "ScriptTextOut should return 0 not (%08x)\n", hr);
 467             ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
 468
 469             iCP = 1;
 470             hr = ScriptCPtoX(iCP, fTrailing, cChars, pcGlyphs, (const WORD *) &pwLogClust,
 471                             (const SCRIPT_VISATTR *) &psva, (const int *)&piAdvance, &pItem[0].a, &piX);
 472             ok(hr == S_OK, "ScriptCPtoX Stub should return S_OK not %08x\n", hr);
 473
 474             psla = (SCRIPT_LOGATTR *)&sla;
 475             hr = ScriptBreak(TestItem1, cChars, &pItem[0].a, psla);
 476             ok(hr == S_OK, "ScriptBreak Stub should return S_OK not %08x\n", hr);
 477
 478             /* Clean up and go   */
 479             ScriptFreeCache(&psc);
 480             ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
 481         }
 482     }
 483 }
 484
 485 static void test_ScriptXtoX(void)
 486 /****************************************************************************************
 487  *  This routine tests the ScriptXtoCP and ScriptCPtoX functions using static variables *
 488  ****************************************************************************************/
 489 {
 490     int iX, iCP;
 491     int cChars;
 492     int cGlyphs;
 493     WORD pwLogClust[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 494     SCRIPT_VISATTR psva[10];
 495     int piAdvance[10] = {200, 190, 210, 180, 170, 204, 189, 195, 212, 203};
 496     SCRIPT_ANALYSIS psa;
 497     int piCP, piX;
 498     int piTrailing;
 499     BOOL fTrailing;
 500     HRESULT hr;
 501
 502     iX = -1;
 503     cChars = 10;
 504     cGlyphs = 10;
 505     hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &psa, &piCP, &piTrailing);
 506     ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
 507     ok(piCP == -1, "Negative iX should return piCP=-1 not %d\n", piCP);
 508     ok(piTrailing == TRUE, "Negative iX should return piTrailing=TRUE not %d\n", piTrailing);
 509     iX = 1954;
 510     cChars = 10;
 511     cGlyphs = 10;
 512     hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &psa, &piCP, &piTrailing);
 513     ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
 514     ok(piCP == 10, "Excessive iX should return piCP=10 not %d\n", piCP);
 515     ok(piTrailing == FALSE, "Excessive iX should return piTrailing=FALSE not %d\n", piTrailing);
 516     iX = 779;
 517     cChars = 10;
 518     cGlyphs = 10;
 519     hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &psa, &piCP, &piTrailing);
 520     ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
 521     ok(piCP == 3, "iX=%d should return piCP=3 not %d\n", iX, piCP);
 522     ok(piTrailing == 1, "iX=%d should return piTrailing=1 not %d\n", iX, piTrailing);
 523     iX = 780;
 524     cChars = 10;
 525     cGlyphs = 10;
 526     hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &psa, &piCP, &piTrailing);
 527     ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
 528     ok(piCP == 3, "iX=%d should return piCP=3 not %d\n", iX, piCP);
 529     ok(piTrailing == 1, "iX=%d should return piTrailing=1 not %d\n", iX, piTrailing);
 530     iX = 868;
 531     cChars = 10;
 532     cGlyphs = 10;
 533     hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &psa, &piCP, &piTrailing);
 534     ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
 535     ok(piCP == 4, "iX=%d should return piCP=4 not %d\n", iX, piCP);
 536
 537     iX = 0;
 538     cChars = 10;
 539     cGlyphs = 10;
 540     hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &psa, &piCP, &piTrailing);
 541     ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
 542     ok(piCP == 0, "iX=%d should return piCP=0 not %d\n", iX, piCP);
 543     iX = 195;
 544     cChars = 10;
 545     cGlyphs = 10;
 546     hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &psa, &piCP, &piTrailing);
 547     ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
 548     ok(piCP == 0, "iX=%d should return piCP=0 not %d\n", iX, piCP);
 549     iX = 196;
 550     cChars = 10;
 551     cGlyphs = 10;
 552     hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &psa, &piCP, &piTrailing);
 553     ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
 554     ok(piCP == 1, "iX=%d should return piCP=1 not %d\n", iX, piCP);
 555
 556     iCP=5;
 557     fTrailing = FALSE;
 558     cChars = 10;
 559     cGlyphs = 10;
 560     hr = ScriptCPtoX(iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance, &psa, &piX);
 561     ok(hr == S_OK, "ScriptCPtoX should return S_OK not %08x\n", hr);
 562     ok(piX == 976, "iCP=%d should return piX=976 not %d\n", iCP, piX);
 563     iCP=5;
 564     fTrailing = TRUE;
 565     cChars = 10;
 566     cGlyphs = 10;
 567     hr = ScriptCPtoX(iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance, &psa, &piX);
 568     ok(hr == S_OK, "ScriptCPtoX should return S_OK not %08x\n", hr);
 569     ok(piX == 1171, "iCP=%d should return piX=1171 not %d\n", iCP, piX);
 570     iCP=6;
 571     fTrailing = FALSE;
 572     cChars = 10;
 573     cGlyphs = 10;
 574     hr = ScriptCPtoX(iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance, &psa, &piX);
 575     ok(hr == S_OK, "ScriptCPtoX should return S_OK not %08x\n", hr);
 576     ok(piX == 1171, "iCP=%d should return piX=1171 not %d\n", iCP, piX);
 577     iCP=11;
 578     fTrailing = FALSE;
 579     cChars = 10;
 580     cGlyphs = 10;
 581     hr = ScriptCPtoX(iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance, &psa, &piX);
 582     ok(hr == S_OK, "ScriptCPtoX should return S_OK not %08x\n", hr);
 583     ok(piX == 1953, "iCP=%d should return piX=1953 not %d\n", iCP, piX);
 584     iCP=11;
 585     fTrailing = TRUE;
 586     cChars = 10;
 587     cGlyphs = 10;
 588     hr = ScriptCPtoX(iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance, &psa, &piX);
 589     ok(hr == S_OK, "ScriptCPtoX should return S_OK not %08x\n", hr);
 590     ok(piX == 1953, "iCP=%d should return piX=1953 not %d\n", iCP, piX);
 591
 592 }
 593
 594 static void test_ScriptString(HDC hdc)
 595 {
 596 /*******************************************************************************************
 597  *
 598  * This set of tests are for the string functions of uniscribe.  The ScriptStringAnalyse
 599  * function allocates memory pointed to by the SCRIPT_STRING_ANALYSIS ssa pointer.  This
 600  * memory if freed by ScriptStringFree.  There needs to be a valid hdc for this as
 601  * ScriptStringAnalyse calls ScriptSItemize, ScriptShape and ScriptPlace which require it.
 602  *
 603  */
 604
 605     HRESULT         hr;
 606     WCHAR           teststr[] = {'T','e','s','t','1',' ','a','2','b','3', '\0'};
 607     int             len = (sizeof(teststr) / sizeof(WCHAR)) - 1;
 608     int             Glyphs = len * 2 + 16;
 609     int             Charset;
 610     DWORD           Flags = SSA_GLYPHS;
 611     int             ReqWidth = 100;
 612     SCRIPT_CONTROL  Control;
 613     SCRIPT_STATE    State;
 614     const int       Dx[5] = {10, 10, 10, 10, 10};
 615     SCRIPT_TABDEF   Tabdef;
 616     const BYTE      InClass = 0;
 617     SCRIPT_STRING_ANALYSIS ssa = NULL;
 618
 619     int             X = 10;
 620     int             Y = 100;
 621     UINT            Options = 0;
 622     const RECT      rc = {0, 50, 100, 100};
 623     int             MinSel = 0;
 624     int             MaxSel = 0;
 625     BOOL            Disabled = FALSE;
 626     const int      *clip_len;
 627     int            i;
 628     UINT           *order;
 629
 630
 631     Charset = -1;     /* this flag indicates unicode input */
 632     /* Test without hdc to get E_PENDING */
 633     hr = ScriptStringAnalyse( NULL, teststr, len, Glyphs, Charset, Flags,
 634                              ReqWidth, &Control, &State, Dx, &Tabdef,
 635                              &InClass, &ssa);
 636     ok(hr == E_PENDING, "ScriptStringAnalyse Stub should return E_PENDING not %08x\n", hr);
 637
 638     /* test with hdc, this should be a valid test  */
 639     hr = ScriptStringAnalyse( hdc, teststr, len, Glyphs, Charset, Flags,
 640                               ReqWidth, &Control, &State, Dx, &Tabdef,
 641                               &InClass, &ssa);
 642     ok(hr == S_OK, "ScriptStringAnalyse should return S_OK not %08x\n", hr);
 643     ScriptStringFree(&ssa);
 644
 645     /* test makes sure that a call with a valid pssa still works */
 646     hr = ScriptStringAnalyse( hdc, teststr, len, Glyphs, Charset, Flags,
 647                               ReqWidth, &Control, &State, Dx, &Tabdef,
 648                               &InClass, &ssa);
 649     ok(hr == S_OK, "ScriptStringAnalyse should return S_OK not %08x\n", hr);
 650     ok(ssa != NULL, "ScriptStringAnalyse pssa should not be NULL\n");
 651
 652     if (hr == S_OK)
 653     {
 654         hr = ScriptStringOut(ssa, X, Y, Options, &rc, MinSel, MaxSel, Disabled);
 655         ok(hr == S_OK, "ScriptStringOut should return S_OK not %08x\n", hr);
 656     }
 657
 658      clip_len = ScriptString_pcOutChars(ssa);
 659      ok(*clip_len == len, "ScriptString_pcOutChars failed, got %d, expected %d\n", *clip_len, len);
 660
 661      order = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *clip_len * sizeof(UINT));
 662      hr = ScriptStringGetOrder(ssa, order);
 663      ok(hr == S_OK, "ScriptStringGetOrder failed, got %08x, expected S_OK\n", hr);
 664
 665      for (i = 0; i < *clip_len; i++) ok(order[i] == i, "%d: got %d expected %d\n", i, order[i], i);
 666      HeapFree(GetProcessHeap(), 0, order);
 667
 668      hr = ScriptStringFree(&ssa);
 669      ok(hr == S_OK, "ScriptStringFree should return S_OK not %08x\n", hr);
 670 }
 671
 672 static void test_ScriptStringXtoCP_CPtoX(HDC hdc)
 673 {
 674 /*****************************************************************************************
 675  *
 676  * This test is for the ScriptStringXtoCP and ScriptStringXtoCP functions.  Due to the
 677  * nature of the fonts between Windows and Wine, the test is implemented by generating
 678  * values using one one function then checking the output of the second.  In this way
 679  * the validity of the functions is established using Windows as a base and confirming
 680  * similar behaviour in wine.
 681  */
 682
 683     HRESULT         hr;
 684     WCHAR           teststr1[] = {'T', 'e', 's', 't', 'e', '1', '2', ' ', 'a', '\0'};
 685     void            *String = (WCHAR *) &teststr1;      /* ScriptStringAnalysis needs void */
 686     int             String_len = (sizeof(teststr1)/sizeof(WCHAR))-1;
 687     int             Glyphs = String_len * 2 + 16;       /* size of buffer as recommended  */
 688     int             Charset = -1;                       /* unicode                        */
 689     DWORD           Flags = SSA_GLYPHS;
 690     int             ReqWidth = 100;
 691     SCRIPT_CONTROL  Control;
 692     SCRIPT_STATE    State;
 693     SCRIPT_TABDEF   Tabdef;
 694     const BYTE      InClass = 0;
 695     SCRIPT_STRING_ANALYSIS ssa = NULL;
 696
 697     int             Ch;                                  /* Character position in string */
 698     int             iTrailing;
 699     int             Cp;                                  /* Character position in string */
 700     int             X;
 701     BOOL            fTrailing;
 702
 703     /* Test with hdc, this should be a valid test
 704      * Here we generrate an SCRIPT_STRING_ANALYSIS that will be used as input to the
 705      * following character positions to X and X to character position functions.
 706      */
 707     hr = ScriptStringAnalyse( hdc, String, String_len, Glyphs, Charset, Flags,
 708                               ReqWidth, &Control, &State, NULL, &Tabdef,
 709                               &InClass, &ssa);
 710     ok(hr == S_OK, "ScriptStringAnalyse should return S_OK not %08x\n", hr);
 711     ok(ssa != NULL, "ScriptStringAnalyse ssa should not be NULL\n");
 712     if  (hr == 0)
 713     {
 714         /*
 715          * Loop to generate character positions to provide starting positions for the
 716          * ScriptStringCPtoX and ScriptStringXtoCP functions
 717          */
 718         for (Cp = 0; Cp < String_len; Cp++)
 719         {
 720             /* The fTrailing flag is used to indicate whether the X being returned is at
 721              * the beginning or the end of the character. What happens here is that if
 722              * fTrailing indicates the end of the character, ie. FALSE, then ScriptStringXtoCP
 723              * returns the beginning of the next character and iTrailing is FALSE.  So for this
 724              * loop iTrailing will be FALSE in both cases.
 725              */
 726             fTrailing = FALSE;
 727             hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
 728             ok(hr == S_OK, "ScriptStringCPtoX should return S_OK not %08x\n", hr);
 729             hr = ScriptStringXtoCP(ssa, X, &Ch, &iTrailing);
 730             ok(hr == S_OK, "ScriptStringXtoCP should return S_OK not %08x\n", hr);
 731             ok(Cp == Ch, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp, Ch, X);
 732             ok(iTrailing == FALSE, "ScriptStringXtoCP should return iTrailing = 0 not %d for X = %d\n",
 733                                   iTrailing, X);
 734             fTrailing = TRUE;
 735             hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
 736             ok(hr == S_OK, "ScriptStringCPtoX should return S_OK not %08x\n", hr);
 737             hr = ScriptStringXtoCP(ssa, X, &Ch, &iTrailing);
 738             ok(hr == S_OK, "ScriptStringXtoCP should return S_OK not %08x\n", hr);
 739
 740             /*
 741              * Check that character position returned by ScriptStringXtoCP in Ch matches the
 742              * one input to ScriptStringCPtoX.  This means that the Cp to X position and back
 743              * again works
 744              */
 745             ok(Cp + 1 == Ch, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp + 1, Ch, X);
 746             ok(iTrailing == FALSE, "ScriptStringXtoCP should return iTrailing = 0 not %d for X = %d\n",
 747                                    iTrailing, X);
 748         }
 749         /*
 750          * This test is to check that if the X position is just inside the trailing edge of the
 751          * character then iTrailing will indicate the trailing edge, ie. TRUE
 752          */
 753         fTrailing = TRUE;
 754         Cp = 3;
 755         hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
 756         ok(hr == S_OK, "ScriptStringCPtoX should return S_OK not %08x\n", hr);
 757         X--;                                /* put X just inside the trailing edge */
 758         hr = ScriptStringXtoCP(ssa, X, &Ch, &iTrailing);
 759         ok(hr == S_OK, "ScriptStringXtoCP should return S_OK not %08x\n", hr);
 760         ok(Cp == Ch, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp, Ch, X);
 761         ok(iTrailing == TRUE, "ScriptStringXtoCP should return iTrailing = 1 not %d for X = %d\n",
 762                                   iTrailing, X);
 763
 764         /*
 765          * This test is to check that if the X position is just outside the trailing edge of the
 766          * character then iTrailing will indicate the leading edge, ie. FALSE, and Ch will indicate
 767          * the next character, ie. Cp + 1
 768          */
 769         fTrailing = TRUE;
 770         Cp = 3;
 771         hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
 772         ok(hr == S_OK, "ScriptStringCPtoX should return S_OK not %08x\n", hr);
 773         X++;                                /* put X just outside the trailing edge */
 774         hr = ScriptStringXtoCP(ssa, X, &Ch, &iTrailing);
 775         ok(hr == S_OK, "ScriptStringXtoCP should return S_OK not %08x\n", hr);
 776         ok(Cp + 1 == Ch, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp + 1, Ch, X);
 777         ok(iTrailing == FALSE, "ScriptStringXtoCP should return iTrailing = 0 not %d for X = %d\n",
 778                                   iTrailing, X);
 779
 780         /*
 781          * This test is to check that if the X position is just outside the leading edge of the
 782          * character then iTrailing will indicate the trailing edge, ie. TRUE, and Ch will indicate
 783          * the next character down , ie. Cp - 1
 784          */
 785         fTrailing = FALSE;
 786         Cp = 3;
 787         hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
 788         ok(hr == S_OK, "ScriptStringCPtoX should return S_OK not %08x\n", hr);
 789         X--;                                /* put X just outside the leading edge */
 790         hr = ScriptStringXtoCP(ssa, X, &Ch, &iTrailing);
 791         ok(hr == S_OK, "ScriptStringXtoCP should return S_OK not %08x\n", hr);
 792         ok(Cp - 1 == Ch, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp - 1, Ch, X);
 793         ok(iTrailing == TRUE, "ScriptStringXtoCP should return iTrailing = 1 not %d for X = %d\n",
 794                                   iTrailing, X);
 795
 796         /*
 797          * Cleanup the SSA for the next round of tests
 798          */
 799         hr = ScriptStringFree(&ssa);
 800         ok(hr == S_OK, "ScriptStringFree should return S_OK not %08x\n", hr);
 801
 802         /*
 803          * Test to see that exceeding the number of chars returns E_INVALIDARG.  First
 804          * generate an SSA for the subsequent tests.
 805          */
 806         hr = ScriptStringAnalyse( hdc, String, String_len, Glyphs, Charset, Flags,
 807                                   ReqWidth, &Control, &State, NULL, &Tabdef,
 808                                   &InClass, &ssa);
 809         ok(hr == S_OK, "ScriptStringAnalyse should return S_OK not %08x\n", hr);
 810
 811         /*
 812          * When ScriptStringCPtoX is called with a character position Cp that exceeds the
 813          * string length, return E_INVALIDARG.  This also invalidates the ssa so a
 814          * ScriptStringFree should also fail.
 815          */
 816         fTrailing = FALSE;
 817         Cp = String_len + 1;
 818         hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
 819         ok(hr == E_INVALIDARG, "ScriptStringCPtoX should return E_INVALIDARG not %08x\n", hr);
 820
 821         hr = ScriptStringFree(&ssa);
 822         /*
 823          * ScriptStringCPtoX should free ssa, hence ScriptStringFree should fail
 824          */
 825         ok(hr == E_INVALIDARG, "ScriptStringFree should return E_INVALIDARG not %08x\n", hr);
 826     }
 827 }
 828
 829 static void test_ScriptCacheGetHeight(HDC hdc)
 830 {
 831     HRESULT hr;
 832     SCRIPT_CACHE sc = NULL;
 833     LONG height;
 834
 835     hr = ScriptCacheGetHeight(NULL, NULL, NULL);
 836     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
 837
 838     hr = ScriptCacheGetHeight(NULL, &sc, NULL);
 839     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
 840
 841     hr = ScriptCacheGetHeight(NULL, &sc, &height);
 842     ok(hr == E_PENDING, "expected E_PENDING, got 0x%08x\n", hr);
 843
 844     height = 0;
 845
 846     hr = ScriptCacheGetHeight(hdc, &sc, &height);
 847     ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
 848     ok(height > 0, "expected height > 0\n");
 849
 850     ScriptFreeCache(&sc);
 851 }
 852
 853 static void test_ScriptGetGlyphABCWidth(HDC hdc)
 854 {
 855     HRESULT hr;
 856     SCRIPT_CACHE sc = NULL;
 857     ABC abc;
 858
 859     hr = ScriptGetGlyphABCWidth(NULL, NULL, 'a', NULL);
 860     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
 861
 862     hr = ScriptGetGlyphABCWidth(NULL, &sc, 'a', NULL);
 863     ok(hr == E_PENDING, "expected E_PENDING, got 0x%08x\n", hr);
 864
 865     if (0) {    /* crashes on WinXP */
 866     hr = ScriptGetGlyphABCWidth(hdc, &sc, 'a', NULL);
 867     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
 868     }
 869
 870     hr = ScriptGetGlyphABCWidth(hdc, &sc, 'a', &abc);
 871     ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
 872
 873     ScriptFreeCache(&sc);
 874 }
 875
 876 static void test_ScriptLayout(void)
 877 {
 878     HRESULT hr;
 879     static const BYTE levels[][5] =
 880     {
 881         { 0, 0, 0, 0, 0 },
 882         { 1, 1, 1, 1, 1 },
 883         { 2, 2, 2, 2, 2 },
 884         { 3, 3, 3, 3, 3 },
 885     };
 886     static const int expect[][5] =
 887     {
 888         { 0, 1, 2, 3, 4 },
 889         { 4, 3, 2, 1, 0 },
 890         { 0, 1, 2, 3, 4 },
 891         { 4, 3, 2, 1, 0 }
 892     };
 893     int i, j, vistolog[sizeof(levels[0])], logtovis[sizeof(levels[0])];
 894
 895     hr = ScriptLayout(sizeof(levels[0]), NULL, vistolog, logtovis);
 896     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
 897
 898     hr = ScriptLayout(sizeof(levels[0]), levels[0], NULL, NULL);
 899     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
 900
 901     for (i = 0; i < sizeof(levels)/sizeof(levels[0]); i++)
 902     {
 903         hr = ScriptLayout(sizeof(levels[0]), levels[i], vistolog, logtovis);
 904         ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
 905
 906         for (j = 0; j < sizeof(levels[i]); j++)
 907         {
 908             ok(expect[i][j] == vistolog[j],
 909                "failure: levels[%d][%d] = %d, vistolog[%d] = %d\n",
 910                i, j, levels[i][j], j, vistolog[j] );
 911         }
 912
 913         for (j = 0; j < sizeof(levels[i]); j++)
 914         {
 915             ok(expect[i][j] == logtovis[j],
 916                "failure: levels[%d][%d] = %d, logtovis[%d] = %d\n",
 917                i, j, levels[i][j], j, logtovis[j] );
 918         }
 919     }
 920 }
 921
 922 static const struct
 923 {
 924     LGRPID group;
 925     LCID lcid;
 926     SCRIPT_DIGITSUBSTITUTE sds;
 927     DWORD uDefaultLanguage;
 928     DWORD fContextDigits;
 929     WORD fDigitSubstitute;
 930 }
 931 subst_data[] =
 932 {
 933     { 0x01, 0x00403, { 9, 3, 1, 0 }, 9, 0, 0 },
 934     { 0x01, 0x00406, { 9, 6, 1, 0 }, 9, 0, 0 },
 935     { 0x01, 0x00407, { 9, 7, 1, 0 }, 9, 0, 0 },
 936     { 0x01, 0x00409, { 9, 9, 1, 0 }, 9, 0, 0 },
 937     { 0x01, 0x0040a, { 9, 10, 1, 0 }, 9, 0, 0 },
 938     { 0x01, 0x0040b, { 9, 11, 1, 0 }, 9, 0, 0 },
 939     { 0x01, 0x0040c, { 9, 12, 1, 0 }, 9, 0, 0 },
 940     { 0x01, 0x0040f, { 9, 15, 1, 0 }, 9, 0, 0 },
 941     { 0x01, 0x00410, { 9, 16, 1, 0 }, 9, 0, 0 },
 942     { 0x01, 0x00413, { 9, 19, 1, 0 }, 9, 0, 0 },
 943     { 0x01, 0x00414, { 9, 20, 1, 0 }, 9, 0, 0 },
 944     { 0x01, 0x00416, { 9, 22, 1, 0 }, 9, 0, 0 },
 945     { 0x01, 0x0041d, { 9, 29, 1, 0 }, 9, 0, 0 },
 946     { 0x01, 0x00421, { 9, 33, 1, 0 }, 9, 0, 0 },
 947     { 0x01, 0x0042d, { 9, 45, 1, 0 }, 9, 0, 0 },
 948     { 0x01, 0x00432, { 9, 50, 1, 0 }, 9, 0, 0 },
 949     { 0x01, 0x00434, { 9, 52, 1, 0 }, 9, 0, 0 },
 950     { 0x01, 0x00435, { 9, 53, 1, 0 }, 9, 0, 0 },
 951     { 0x01, 0x00436, { 9, 54, 1, 0 }, 9, 0, 0 },
 952     { 0x01, 0x00438, { 9, 56, 1, 0 }, 9, 0, 0 },
 953     { 0x01, 0x0043a, { 9, 58, 1, 0 }, 9, 0, 0 },
 954     { 0x01, 0x0043b, { 9, 59, 1, 0 }, 9, 0, 0 },
 955     { 0x01, 0x0043e, { 9, 62, 1, 0 }, 9, 0, 0 },
 956     { 0x01, 0x00441, { 9, 65, 1, 0 }, 9, 0, 0 },
 957     { 0x01, 0x00452, { 9, 82, 1, 0 }, 9, 0, 0 },
 958     { 0x01, 0x00456, { 9, 86, 1, 0 }, 9, 0, 0 },
 959     { 0x01, 0x0046b, { 9, 107, 1, 0 }, 9, 0, 0 },
 960     { 0x01, 0x0046c, { 9, 108, 1, 0 }, 9, 0, 0 },
 961     { 0x01, 0x00481, { 9, 129, 1, 0 }, 9, 0, 0 },
 962     { 0x01, 0x00807, { 9, 7, 1, 0 }, 9, 0, 0 },
 963     { 0x01, 0x00809, { 9, 9, 1, 0 }, 9, 0, 0 },
 964     { 0x01, 0x0080a, { 9, 10, 1, 0 }, 9, 0, 0 },
 965     { 0x01, 0x0080c, { 9, 12, 1, 0 }, 9, 0, 0 },
 966     { 0x01, 0x00810, { 9, 16, 1, 0 }, 9, 0, 0 },
 967     { 0x01, 0x00813, { 9, 19, 1, 0 }, 9, 0, 0 },
 968     { 0x01, 0x00814, { 9, 20, 1, 0 }, 9, 0, 0 },
 969     { 0x01, 0x00816, { 9, 22, 1, 0 }, 9, 0, 0 },
 970     { 0x01, 0x0081d, { 9, 29, 1, 0 }, 9, 0, 0 },
 971     { 0x01, 0x0083b, { 9, 59, 1, 0 }, 9, 0, 0 },
 972     { 0x01, 0x0083e, { 9, 62, 1, 0 }, 9, 0, 0 },
 973     { 0x01, 0x0086b, { 9, 107, 1, 0 }, 9, 0, 0 },
 974     { 0x01, 0x00c07, { 9, 7, 1, 0 }, 9, 0, 0 },
 975     { 0x01, 0x00c09, { 9, 9, 1, 0 }, 9, 0, 0 },
 976     { 0x01, 0x00c0a, { 9, 10, 1, 0 }, 9, 0, 0 },
 977     { 0x01, 0x00c0c, { 9, 12, 1, 0 }, 9, 0, 0 },
 978     { 0x01, 0x00c3b, { 9, 59, 1, 0 }, 9, 0, 0 },
 979     { 0x01, 0x00c6b, { 9, 107, 1, 0 }, 9, 0, 0 },
 980     { 0x01, 0x01007, { 9, 7, 1, 0 }, 9, 0, 0 },
 981     { 0x01, 0x01009, { 9, 9, 1, 0 }, 9, 0, 0 },
 982     { 0x01, 0x0100a, { 9, 10, 1, 0 }, 9, 0, 0 },
 983     { 0x01, 0x0100c, { 9, 12, 1, 0 }, 9, 0, 0 },
 984     { 0x01, 0x0103b, { 9, 59, 1, 0 }, 9, 0, 0 },
 985     { 0x01, 0x01407, { 9, 7, 1, 0 }, 9, 0, 0 },
 986     { 0x01, 0x01409, { 9, 9, 1, 0 }, 9, 0, 0 },
 987     { 0x01, 0x0140a, { 9, 10, 1, 0 }, 9, 0, 0 },
 988     { 0x01, 0x0140c, { 9, 12, 1, 0 }, 9, 0, 0 },
 989     { 0x01, 0x0143b, { 9, 59, 1, 0 }, 9, 0, 0 },
 990     { 0x01, 0x01809, { 9, 9, 1, 0 }, 9, 0, 0 },
 991     { 0x01, 0x0180a, { 9, 10, 1, 0 }, 9, 0, 0 },
 992     { 0x01, 0x0180c, { 9, 12, 1, 0 }, 9, 0, 0 },
 993     { 0x01, 0x0183b, { 9, 59, 1, 0 }, 9, 0, 0 },
 994     { 0x01, 0x01c09, { 9, 9, 1, 0 }, 9, 0, 0 },
 995     { 0x01, 0x01c0a, { 9, 10, 1, 0 }, 9, 0, 0 },
 996     { 0x01, 0x01c3b, { 9, 59, 1, 0 }, 9, 0, 0 },
 997     { 0x01, 0x02009, { 9, 9, 1, 0 }, 9, 0, 0 },
 998     { 0x01, 0x0200a, { 9, 10, 1, 0 }, 9, 0, 0 },
 999     { 0x01, 0x0203b, { 9, 59, 1, 0 }, 9, 0, 0 },
1000     { 0x01, 0x02409, { 9, 9, 1, 0 }, 9, 0, 0 },
1001     { 0x01, 0x0240a, { 9, 10, 1, 0 }, 9, 0, 0 },
1002     { 0x01, 0x0243b, { 9, 59, 1, 0 }, 9, 0, 0 },
1003     { 0x01, 0x02809, { 9, 9, 1, 0 }, 9, 0, 0 },
1004     { 0x01, 0x0280a, { 9, 10, 1, 0 }, 9, 0, 0 },
1005     { 0x01, 0x02c09, { 9, 9, 1, 0 }, 9, 0, 0 },
1006     { 0x01, 0x02c0a, { 9, 10, 1, 0 }, 9, 0, 0 },
1007     { 0x01, 0x03009, { 9, 9, 1, 0 }, 9, 0, 0 },
1008     { 0x01, 0x0300a, { 9, 10, 1, 0 }, 9, 0, 0 },
1009     { 0x01, 0x03409, { 9, 9, 1, 0 }, 9, 0, 0 },
1010     { 0x01, 0x0340a, { 9, 10, 1, 0 }, 9, 0, 0 },
1011     { 0x01, 0x0380a, { 9, 10, 1, 0 }, 9, 0, 0 },
1012     { 0x01, 0x03c0a, { 9, 10, 1, 0 }, 9, 0, 0 },
1013     { 0x01, 0x0400a, { 9, 10, 1, 0 }, 9, 0, 0 },
1014     { 0x01, 0x0440a, { 9, 10, 1, 0 }, 9, 0, 0 },
1015     { 0x01, 0x0480a, { 9, 10, 1, 0 }, 9, 0, 0 },
1016     { 0x01, 0x04c0a, { 9, 10, 1, 0 }, 9, 0, 0 },
1017     { 0x01, 0x0500a, { 9, 10, 1, 0 }, 9, 0, 0 },
1018     { 0x01, 0x10407, { 9, 7, 1, 0 }, 9, 0, 0 },
1019     { 0x02, 0x00405, { 9, 5, 1, 0 }, 9, 0, 0 },
1020     { 0x02, 0x0040e, { 9, 14, 1, 0 }, 9, 0, 0 },
1021     { 0x02, 0x00415, { 9, 21, 1, 0 }, 9, 0, 0 },
1022     { 0x02, 0x00418, { 9, 24, 1, 0 }, 9, 0, 0 },
1023     { 0x02, 0x0041a, { 9, 26, 1, 0 }, 9, 0, 0 },
1024     { 0x02, 0x0041b, { 9, 27, 1, 0 }, 9, 0, 0 },
1025     { 0x02, 0x0041c, { 9, 28, 1, 0 }, 9, 0, 0 },
1026     { 0x02, 0x00424, { 9, 36, 1, 0 }, 9, 0, 0 },
1027     { 0x02, 0x0081a, { 9, 26, 1, 0 }, 9, 0, 0 },
1028     { 0x02, 0x0101a, { 9, 26, 1, 0 }, 9, 0, 0 },
1029     { 0x02, 0x0141a, { 9, 26, 1, 0 }, 9, 0, 0 },
1030     { 0x02, 0x0181a, { 9, 26, 1, 0 }, 9, 0, 0 },
1031     { 0x02, 0x1040e, { 9, 14, 1, 0 }, 9, 0, 0 },
1032     { 0x03, 0x00425, { 9, 37, 1, 0 }, 9, 0, 0 },
1033     { 0x03, 0x00426, { 9, 38, 1, 0 }, 9, 0, 0 },
1034     { 0x03, 0x00427, { 9, 39, 1, 0 }, 9, 0, 0 },
1035     { 0x04, 0x00408, { 9, 8, 1, 0 }, 9, 0, 0 },
1036     { 0x05, 0x00402, { 9, 2, 1, 0 }, 9, 0, 0 },
1037     { 0x05, 0x00419, { 9, 25, 1, 0 }, 9, 0, 0 },
1038     { 0x05, 0x00422, { 9, 34, 1, 0 }, 9, 0, 0 },
1039     { 0x05, 0x00423, { 9, 35, 1, 0 }, 9, 0, 0 },
1040     { 0x05, 0x0042f, { 9, 47, 1, 0 }, 9, 0, 0 },
1041     { 0x05, 0x0043f, { 9, 63, 1, 0 }, 9, 0, 0 },
1042     { 0x05, 0x00440, { 9, 64, 1, 0 }, 9, 0, 0 },
1043     { 0x05, 0x00444, { 9, 68, 1, 0 }, 9, 0, 0 },
1044     { 0x05, 0x00450, { 9, 80, 1, 0 }, 9, 0, 0 },
1045     { 0x05, 0x0082c, { 9, 44, 1, 0 }, 9, 0, 0 },
1046     { 0x05, 0x00843, { 9, 67, 1, 0 }, 9, 0, 0 },
1047     { 0x05, 0x00c1a, { 9, 26, 1, 0 }, 9, 0, 0 },
1048     { 0x05, 0x01c1a, { 9, 26, 1, 0 }, 9, 0, 0 },
1049     { 0x06, 0x0041f, { 9, 31, 1, 0 }, 9, 0, 0 },
1050     { 0x06, 0x0042c, { 9, 44, 1, 0 }, 9, 0, 0 },
1051     { 0x06, 0x00443, { 9, 67, 1, 0 }, 9, 0, 0 },
1052     { 0x07, 0x00411, { 9, 17, 1, 0 }, 9, 0, 0 },
1053     { 0x08, 0x00412, { 9, 18, 1, 0 }, 9, 0, 0 },
1054     { 0x09, 0x00404, { 9, 4, 1, 0 }, 9, 0, 0 },
1055     { 0x09, 0x00c04, { 9, 4, 1, 0 }, 9, 0, 0 },
1056     { 0x09, 0x01404, { 9, 4, 1, 0 }, 9, 0, 0 },
1057     { 0x09, 0x21404, { 9, 4, 1, 0 }, 9, 0, 0 },
1058     { 0x09, 0x30404, { 9, 4, 1, 0 }, 9, 0, 0 },
1059     { 0x0a, 0x00804, { 9, 4, 1, 0 }, 9, 0, 0 },
1060     { 0x0a, 0x01004, { 9, 4, 1, 0 }, 9, 0, 0 },
1061     { 0x0a, 0x20804, { 9, 4, 1, 0 }, 9, 0, 0 },
1062     { 0x0a, 0x21004, { 9, 4, 1, 0 }, 9, 0, 0 },
1063     { 0x0b, 0x0041e, { 9, 30, 1, 0 }, 9, 0, 0 },
1064     { 0x0c, 0x0040d, { 9, 13, 1, 0 }, 9, 0, 0 },
1065     { 0x0d, 0x00401, { 1, 1, 0, 0 }, 9, 0, 0 },
1066     { 0x0d, 0x00420, { 9, 32, 1, 0 }, 9, 0, 0 },
1067     { 0x0d, 0x00429, { 41, 41, 0, 0 }, 9, 0, 0 },
1068     { 0x0d, 0x0045a, { 9, 90, 1, 0 }, 9, 0, 0 },
1069     { 0x0d, 0x00465, { 9, 101, 1, 0 }, 9, 0, 0 },
1070     { 0x0d, 0x00801, { 1, 1, 0, 0 }, 9, 0, 0 },
1071     { 0x0d, 0x00c01, { 1, 1, 0, 0 }, 9, 0, 0 },
1072     { 0x0d, 0x01001, { 1, 1, 0, 0 }, 9, 0, 0 },
1073     { 0x0d, 0x01401, { 1, 1, 0, 0 }, 9, 0, 0 },
1074     { 0x0d, 0x01801, { 1, 1, 0, 0 }, 9, 0, 0 },
1075     { 0x0d, 0x01c01, { 1, 1, 0, 0 }, 9, 0, 0 },
1076     { 0x0d, 0x02001, { 1, 1, 0, 0 }, 9, 0, 0 },
1077     { 0x0d, 0x02401, { 1, 1, 0, 0 }, 9, 0, 0 },
1078     { 0x0d, 0x02801, { 1, 1, 0, 0 }, 9, 0, 0 },
1079     { 0x0d, 0x02c01, { 1, 1, 0, 0 }, 9, 0, 0 },
1080     { 0x0d, 0x03001, { 1, 1, 0, 0 }, 9, 0, 0 },
1081     { 0x0d, 0x03401, { 1, 1, 0, 0 }, 9, 0, 0 },
1082     { 0x0d, 0x03801, { 1, 1, 0, 0 }, 9, 0, 0 },
1083     { 0x0d, 0x03c01, { 1, 1, 0, 0 }, 9, 0, 0 },
1084     { 0x0d, 0x04001, { 1, 1, 0, 0 }, 9, 0, 0 },
1085     { 0x0e, 0x0042a, { 9, 42, 1, 0 }, 9, 0, 0 },
1086     { 0x0f, 0x00439, { 9, 57, 1, 0 }, 9, 0, 0 },
1087     { 0x0f, 0x00446, { 9, 70, 1, 0 }, 9, 0, 0 },
1088     { 0x0f, 0x00447, { 9, 71, 1, 0 }, 9, 0, 0 },
1089     { 0x0f, 0x00449, { 9, 73, 1, 0 }, 9, 0, 0 },
1090     { 0x0f, 0x0044a, { 9, 74, 1, 0 }, 9, 0, 0 },
1091     { 0x0f, 0x0044b, { 9, 75, 1, 0 }, 9, 0, 0 },
1092     { 0x0f, 0x0044e, { 9, 78, 1, 0 }, 9, 0, 0 },
1093     { 0x0f, 0x0044f, { 9, 79, 1, 0 }, 9, 0, 0 },
1094     { 0x0f, 0x00457, { 9, 87, 1, 0 }, 9, 0, 0 },
1095     { 0x10, 0x00437, { 9, 55, 1, 0 }, 9, 0, 0 },
1096     { 0x10, 0x10437, { 9, 55, 1, 0 }, 9, 0, 0 },
1097     { 0x11, 0x0042b, { 9, 43, 1, 0 }, 9, 0, 0 }
1098 };
1099
1100 static BOOL CALLBACK enum_proc(LGRPID group, LCID lcid, LPSTR locale, LONG_PTR lparam)
1101 {
1102     HRESULT hr;
1103     SCRIPT_DIGITSUBSTITUTE sds;
1104     SCRIPT_CONTROL sc;
1105     SCRIPT_STATE ss;
1106     LCID lcid_old;
1107     unsigned int i;
1108
1109     if (!IsValidLocale(lcid, LCID_INSTALLED)) return TRUE;
1110
1111     memset(&sds, 0, sizeof(sds));
1112     memset(&sc, 0, sizeof(sc));
1113     memset(&ss, 0, sizeof(ss));
1114
1115     lcid_old = GetThreadLocale();
1116     if (!SetThreadLocale(lcid)) return TRUE;
1117
1118     hr = ScriptRecordDigitSubstitution(lcid, &sds);
1119     ok(hr == S_OK, "ScriptRecordDigitSubstitution failed: 0x%08x\n", hr);
1120
1121     hr = ScriptApplyDigitSubstitution(&sds, &sc, &ss);
1122     ok(hr == S_OK, "ScriptApplyDigitSubstitution failed: 0x%08x\n", hr);
1123
1124     for (i = 0; i < sizeof(subst_data)/sizeof(subst_data[0]); i++)
1125     {
1126         if (group == subst_data[i].group && lcid == subst_data[i].lcid)
1127         {
1128             ok(!memcmp(&sds, &subst_data[i].sds, sizeof(sds)),
1129                "substitution data does not match\n");
1130
1131             ok(sc.uDefaultLanguage == subst_data[i].uDefaultLanguage,
1132                "sc.uDefaultLanguage does not match\n");
1133             ok(sc.fContextDigits == subst_data[i].fContextDigits,
1134                "sc.fContextDigits does not match\n");
1135             ok(ss.fDigitSubstitute == subst_data[i].fDigitSubstitute,
1136                "ss.fDigitSubstitute does not match\n");
1137         }
1138     }
1139     SetThreadLocale(lcid_old);
1140     return TRUE;
1141 }
1142
1143 static void test_digit_substitution(void)
1144 {
1145     BOOL ret;
1146     unsigned int i;
1147     static const LGRPID groups[] =
1148     {
1149         LGRPID_WESTERN_EUROPE,
1150         LGRPID_CENTRAL_EUROPE,
1151         LGRPID_BALTIC,
1152         LGRPID_GREEK,
1153         LGRPID_CYRILLIC,
1154         LGRPID_TURKISH,
1155         LGRPID_JAPANESE,
1156         LGRPID_KOREAN,
1157         LGRPID_TRADITIONAL_CHINESE,
1158         LGRPID_SIMPLIFIED_CHINESE,
1159         LGRPID_THAI,
1160         LGRPID_HEBREW,
1161         LGRPID_ARABIC,
1162         LGRPID_VIETNAMESE,
1163         LGRPID_INDIC,
1164         LGRPID_GEORGIAN,
1165         LGRPID_ARMENIAN
1166     };
1167     HMODULE hKernel32;
1168     static BOOL (WINAPI * pEnumLanguageGroupLocalesA)(LANGGROUPLOCALE_ENUMPROC,LGRPID,DWORD,LONG_PTR);
1169
1170     hKernel32 = GetModuleHandleA("kernel32.dll");
1171     pEnumLanguageGroupLocalesA = (void*)GetProcAddress(hKernel32, "EnumLanguageGroupLocalesA");
1172
1173     if (!pEnumLanguageGroupLocalesA)
1174     {
1175         trace("EnumLanguageGroupLocalesA not available on this platform\n");
1176         return;
1177     }
1178
1179     for (i = 0; i < sizeof(groups)/sizeof(groups[0]); i++)
1180     {
1181         ret = pEnumLanguageGroupLocalesA(enum_proc, groups[i], 0, 0);
1182         ok(ret, "EnumLanguageGroupLocalesA failed unexpectedly: %u\n", GetLastError());
1183     }
1184 }
1185
1186 static void test_ScriptGetProperties(void)
1187 {
1188     const SCRIPT_PROPERTIES **props;
1189     HRESULT hr;
1190     int num;
1191
1192     hr = ScriptGetProperties(NULL, NULL);
1193     ok(hr == E_INVALIDARG, "ScriptGetProperties succeeded\n");
1194
1195     hr = ScriptGetProperties(NULL, &num);
1196     ok(hr == S_OK, "ScriptGetProperties failed: 0x%08x\n", hr);
1197
1198     hr = ScriptGetProperties(&props, NULL);
1199     ok(hr == S_OK, "ScriptGetProperties failed: 0x%08x\n", hr);
1200
1201     hr = ScriptGetProperties(&props, &num);
1202     ok(hr == S_OK, "ScriptGetProperties failed: 0x%08x\n", hr);
1203 }
1204
1205 START_TEST(usp10)
1206 {
1207     HWND            hwnd;
1208     HDC             hdc;
1209     LOGFONTA        lf;
1210     HFONT           hfont;
1211
1212     unsigned short  pwOutGlyphs[256];
1213
1214     /* We need a valid HDC to drive a lot of Script functions which requires the following    *
1215      * to set up for the tests.                                                               */
1216     hwnd = CreateWindowExA(0, "static", "", WS_POPUP, 0,0,100,100,
1217                            0, 0, 0, NULL);
1218     assert(hwnd != 0);
1219     ShowWindow(hwnd, SW_SHOW);
1220     UpdateWindow(hwnd);
1221
1222     hdc = GetDC(hwnd);                                      /* We now have a hdc             */
1223     ok( hdc != NULL, "HDC failed to be created %p\n", hdc);
1224
1225     memset(&lf, 0, sizeof(LOGFONTA));
1226     lstrcpyA(lf.lfFaceName, "Symbol");
1227     lf.lfHeight = 10;
1228     lf.lfWeight = 3;
1229     lf.lfWidth = 10;
1230
1231     hfont = SelectObject(hdc, CreateFontIndirectA(&lf));
1232
1233     test_ScriptItemIzeShapePlace(hdc,pwOutGlyphs);
1234     test_ScriptGetCMap(hdc, pwOutGlyphs);
1235     test_ScriptCacheGetHeight(hdc);
1236     test_ScriptGetGlyphABCWidth(hdc);
1237
1238     test_ScriptGetFontProperties(hdc);
1239     test_ScriptTextOut(hdc);
1240     test_ScriptXtoX();
1241     test_ScriptString(hdc);
1242     test_ScriptStringXtoCP_CPtoX(hdc);
1243
1244     test_ScriptLayout();
1245     test_digit_substitution();
1246     test_ScriptGetProperties();
1247
1248     ReleaseDC(hwnd, hdc);
1249     DestroyWindow(hwnd);
1250 }