projects / reactos.git / blob
? search:


5795e909cd66ecf947ce66bfc5a92630a0d6e626
[reactos.git] / rostests / winetests / usp10 / 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 <windows.h>
31 #include <usp10.h>
32
33 static void test_ScriptShape(HDC hdc)
34 {
35 static const WCHAR test1[] = {'t', 'e', 's', 't',0};
36 BOOL ret;
37 HRESULT hr;
38 SCRIPT_CACHE sc = NULL;
39 WORD glyphs[4], logclust[4];
40 SCRIPT_VISATTR attrs[4];
41 SCRIPT_ITEM items[2];
42 int nb, widths[4];
43 GOFFSET offset[4];
44 ABC abc[4];
45
46 hr = ScriptItemize(NULL, 4, 2, NULL, NULL, items, NULL);
47 ok(hr == E_INVALIDARG, "ScriptItemize should return E_INVALIDARG not %08x\n", hr);
48
49 hr = ScriptItemize(test1, 4, 2, NULL, NULL, NULL, NULL);
50 ok(hr == E_INVALIDARG, "ScriptItemize should return E_INVALIDARG not %08x\n", hr);
51
52 hr = ScriptItemize(test1, 4, 2, NULL, NULL, items, NULL);
53 ok(!hr, "ScriptItemize should return S_OK not %08x\n", hr);
54 ok(items[0].a.fNoGlyphIndex == FALSE, "fNoGlyphIndex TRUE\n");
55
56 hr = ScriptShape(hdc, &sc, test1, 4, 4, &items[0].a, glyphs, NULL, NULL, &nb);
57 ok(hr == E_INVALIDARG, "ScriptShape should return E_INVALIDARG not %08x\n", hr);
58
59 hr = ScriptShape(hdc, &sc, test1, 4, 4, &items[0].a, glyphs, NULL, attrs, NULL);
60 ok(hr == E_INVALIDARG, "ScriptShape should return E_INVALIDARG not %08x\n", hr);
61
62 hr = ScriptShape(NULL, &sc, test1, 4, 4, &items[0].a, glyphs, NULL, attrs, &nb);
63 ok(hr == E_PENDING, "ScriptShape should return E_PENDING not %08x\n", hr);
64
65 hr = ScriptShape(hdc, &sc, test1, 4, 4, &items[0].a, glyphs, NULL, attrs, &nb);
66 ok(broken(hr == S_OK) ||
67 hr == E_INVALIDARG || /* Vista, W2K8 */
68 hr == E_FAIL, /* WIN7 */
69 "ScriptShape should return E_FAIL or E_INVALIDARG, not %08x\n", hr);
70 ok(items[0].a.fNoGlyphIndex == FALSE, "fNoGlyphIndex TRUE\n");
71
72 hr = ScriptShape(hdc, &sc, test1, 4, 4, &items[0].a, glyphs, logclust, attrs, &nb);
73 ok(!hr, "ScriptShape should return S_OK not %08x\n", hr);
74 ok(items[0].a.fNoGlyphIndex == FALSE, "fNoGlyphIndex TRUE\n");
75
76 hr = ScriptShape(NULL, &sc, test1, 4, 4, &items[0].a, glyphs, logclust, attrs, &nb);
77 ok(!hr, "ScriptShape should return S_OK not %08x\n", hr);
78
79 hr = ScriptPlace(hdc, &sc, glyphs, 4, NULL, &items[0].a, widths, NULL, NULL);
80 ok(hr == E_INVALIDARG, "ScriptPlace should return E_INVALIDARG not %08x\n", hr);
81
82 hr = ScriptPlace(NULL, &sc, glyphs, 4, attrs, &items[0].a, widths, NULL, NULL);
83 ok(broken(hr == E_PENDING) ||
84 hr == E_INVALIDARG || /* Vista, W2K8 */
85 hr == E_FAIL, /* WIN7 */
86 "ScriptPlace should return E_FAIL or E_INVALIDARG, not %08x\n", hr);
87
88 hr = ScriptPlace(NULL, &sc, glyphs, 4, attrs, &items[0].a, widths, offset, NULL);
89 ok(hr == E_PENDING, "ScriptPlace should return E_PENDING not %08x\n", hr);
90
91 hr = ScriptPlace(NULL, &sc, glyphs, 4, attrs, &items[0].a, widths, NULL, abc);
92 ok(broken(hr == E_PENDING) ||
93 hr == E_INVALIDARG || /* Vista, W2K8 */
94 hr == E_FAIL, /* WIN7 */
95 "ScriptPlace should return E_FAIL or E_INVALIDARG, not %08x\n", hr);
96
97 hr = ScriptPlace(hdc, &sc, glyphs, 4, attrs, &items[0].a, widths, offset, NULL);
98 ok(!hr, "ScriptPlace should return S_OK not %08x\n", hr);
99 ok(items[0].a.fNoGlyphIndex == FALSE, "fNoGlyphIndex TRUE\n");
100
101 ret = ExtTextOutW(hdc, 1, 1, 0, NULL, glyphs, 4, widths);
102 ok(ret, "ExtTextOutW should return TRUE\n");
103
104 ScriptFreeCache(&sc);
105 }
106
107 static void test_ScriptItemIzeShapePlace(HDC hdc, unsigned short pwOutGlyphs[256])
108 {
109 HRESULT hr;
110 int iMaxProps;
111 const SCRIPT_PROPERTIES **ppSp;
112
113 int cInChars;
114 int cMaxItems;
115 SCRIPT_ITEM pItem[255];
116 int pcItems;
117 WCHAR TestItem1[] = {'T', 'e', 's', 't', 'a', 0};
118 WCHAR TestItem2[] = {'T', 'e', 's', 't', 'b', 0};
119 WCHAR TestItem3[] = {'T', 'e', 's', 't', 'c',' ','1','2','3',' ',' ','e','n','d',0};
120 WCHAR TestItem4[] = {'T', 'e', 's', 't', 'c',' ',0x0684,0x0694,0x06a4,' ',' ','e','n','d',0};
121 WCHAR TestItem5[] = {0x0684,'T','e','s','t','c',' ',0x0684,0x0694,0x06a4,' ',' ','e','n','d',0};
122
123 SCRIPT_CACHE psc;
124 int cChars;
125 int cMaxGlyphs;
126 unsigned short pwOutGlyphs1[256];
127 unsigned short pwOutGlyphs2[256];
128 unsigned short pwLogClust[256];
129 SCRIPT_VISATTR psva[256];
130 int pcGlyphs;
131 int piAdvance[256];
132 GOFFSET pGoffset[256];
133 ABC pABC[256];
134 int cnt;
135
136 /* Start testing usp10 functions */
137 /* This test determines that the pointer returned by ScriptGetProperties is valid
138 * by checking a known value in the table */
139 hr = ScriptGetProperties(&ppSp, &iMaxProps);
140 trace("number of script properties %d\n", iMaxProps);
141 ok (iMaxProps > 0, "Number of scripts returned should not be 0\n");
142 if (iMaxProps > 0)
143 ok( ppSp[5]->langid == 9, "Langid[5] not = to 9\n"); /* Check a known value to ensure */
144 /* ptrs work */
145
146
147 /* This set of tests are to check that the various edits in ScriptIemize work */
148 cInChars = 5; /* Length of test without NULL */
149 cMaxItems = 1; /* Check threshold value */
150 hr = ScriptItemize(TestItem1, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
151 ok (hr == E_INVALIDARG, "ScriptItemize should return E_INVALIDARG if cMaxItems < 2. Was %d\n",
152 cMaxItems);
153 cInChars = 5;
154 cMaxItems = 255;
155 hr = ScriptItemize(NULL, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
156 ok (hr == E_INVALIDARG, "ScriptItemize should return E_INVALIDARG if pwcInChars is NULL\n");
157
158 cInChars = 5;
159 cMaxItems = 255;
160 hr = ScriptItemize(TestItem1, 0, cMaxItems, NULL, NULL, pItem, &pcItems);
161 ok (hr == E_INVALIDARG, "ScriptItemize should return E_INVALIDARG if cInChars is 0\n");
162
163 cInChars = 5;
164 cMaxItems = 255;
165 hr = ScriptItemize(TestItem1, cInChars, cMaxItems, NULL, NULL, NULL, &pcItems);
166 ok (hr == E_INVALIDARG, "ScriptItemize should return E_INVALIDARG if pItems is NULL\n");
167
168 /* This is a valid test that will cause parsing to take place */
169 cInChars = 5;
170 cMaxItems = 255;
171 hr = ScriptItemize(TestItem1, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
172 ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
173 /* This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
174 * returned. */
175 ok (pcItems > 0, "The number of SCRIPT_ITEMS should be greater than 0\n");
176 if (pcItems > 0)
177 ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == cInChars,
178 "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
179 pItem[0].iCharPos, cInChars, pItem[1].iCharPos);
180
181 /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue
182 * ie. ScriptItemize has succeeded and that pItem has been set */
183 cInChars = 5;
184 cMaxItems = 255;
185 if (hr == 0) {
186 psc = NULL; /* must be null on first call */
187 cChars = cInChars;
188 cMaxGlyphs = cInChars;
189 hr = ScriptShape(NULL, &psc, TestItem1, cChars,
190 cMaxGlyphs, &pItem[0].a,
191 pwOutGlyphs1, pwLogClust, psva, &pcGlyphs);
192 ok (hr == E_PENDING, "If psc is NULL (%08x) the E_PENDING should be returned\n", hr);
193 cMaxGlyphs = 4;
194 hr = ScriptShape(hdc, &psc, TestItem1, cChars,
195 cMaxGlyphs, &pItem[0].a,
196 pwOutGlyphs1, pwLogClust, psva, &pcGlyphs);
197 ok (hr == E_OUTOFMEMORY, "If not enough output area cChars (%d) is > than CMaxGlyphs "
198 "(%d) but not E_OUTOFMEMORY\n",
199 cChars, cMaxGlyphs);
200 cMaxGlyphs = 256;
201 hr = ScriptShape(hdc, &psc, TestItem1, cChars,
202 cMaxGlyphs, &pItem[0].a,
203 pwOutGlyphs1, pwLogClust, psva, &pcGlyphs);
204 ok (hr == 0, "ScriptShape should return 0 not (%08x)\n", hr);
205 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
206 ok (pcGlyphs == cChars, "Chars in (%d) should equal Glyphs out (%d)\n", cChars, pcGlyphs);
207 if (hr ==0) {
208 hr = ScriptPlace(hdc, &psc, pwOutGlyphs1, pcGlyphs, psva, &pItem[0].a, piAdvance,
209 pGoffset, pABC);
210 ok (hr == 0, "ScriptPlace should return 0 not (%08x)\n", hr);
211 hr = ScriptPlace(NULL, &psc, pwOutGlyphs1, pcGlyphs, psva, &pItem[0].a, piAdvance,
212 pGoffset, pABC);
213 ok (hr == 0, "ScriptPlace should return 0 not (%08x)\n", hr);
214 for (cnt=0; cnt < pcGlyphs; cnt++)
215 pwOutGlyphs[cnt] = pwOutGlyphs1[cnt]; /* Send to next function */
216 }
217
218 /* This test will check to make sure that SCRIPT_CACHE is reused and that not translation *
219 * takes place if fNoGlyphIndex is set. */
220
221 cInChars = 5;
222 cMaxItems = 255;
223 hr = ScriptItemize(TestItem2, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
224 ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
225 /* This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
226 * returned. */
227 ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == cInChars,
228 "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
229 pItem[0].iCharPos, cInChars, pItem[1].iCharPos);
230 /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue */
231 if (hr == 0) {
232 cChars = cInChars;
233 cMaxGlyphs = 256;
234 pItem[0].a.fNoGlyphIndex = 1; /* say no translate */
235 hr = ScriptShape(NULL, &psc, TestItem2, cChars,
236 cMaxGlyphs, &pItem[0].a,
237 pwOutGlyphs2, pwLogClust, psva, &pcGlyphs);
238 ok (hr != E_PENDING, "If psc should not be NULL (%08x) and the E_PENDING should be returned\n", hr);
239 ok (hr == 0, "ScriptShape should return 0 not (%08x)\n", hr);
240 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
241 ok (pcGlyphs == cChars, "Chars in (%d) should equal Glyphs out (%d)\n", cChars, pcGlyphs);
242 for (cnt=0; cnt < cChars && TestItem2[cnt] == pwOutGlyphs2[cnt]; cnt++) {}
243 ok (cnt == cChars, "Translation to place when told not to. WCHAR %d - %04x != %04x\n",
244 cnt, TestItem2[cnt], pwOutGlyphs2[cnt]);
245 if (hr ==0) {
246 hr = ScriptPlace(hdc, &psc, pwOutGlyphs2, pcGlyphs, psva, &pItem[0].a, piAdvance,
247 pGoffset, pABC);
248 ok (hr == 0, "ScriptPlace should return 0 not (%08x)\n", hr);
249 }
250 }
251 hr = ScriptFreeCache( &psc);
252 ok (!psc, "psc is not null after ScriptFreeCache\n");
253
254 }
255
256 /* This is a valid test that will cause parsing to take place and create 3 script_items */
257 cInChars = (sizeof(TestItem3)/2)-1;
258 cMaxItems = 255;
259 hr = ScriptItemize(TestItem3, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
260 ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
261 if (hr == 0)
262 {
263 ok (pcItems == 3, "The number of SCRIPT_ITEMS should be 3 not %d\n", pcItems);
264 if (pcItems > 2)
265 {
266 ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == 6,
267 "Start pos [0] not = 0 (%d) or end pos [1] not = %d\n",
268 pItem[0].iCharPos, pItem[1].iCharPos);
269 ok (pItem[1].iCharPos == 6 && pItem[2].iCharPos == 11,
270 "Start pos [1] not = 6 (%d) or end pos [2] not = 11 (%d)\n",
271 pItem[1].iCharPos, pItem[2].iCharPos);
272 ok (pItem[2].iCharPos == 11 && pItem[3].iCharPos == cInChars,
273 "Start pos [2] not = 11 (%d) or end [3] pos not = 14 (%d), cInChars = %d\n",
274 pItem[2].iCharPos, pItem[3].iCharPos, cInChars);
275 }
276 hr = ScriptFreeCache( &psc);
277 ok (!psc, "psc is not null after ScriptFreeCache\n");
278 }
279
280 /* This is a valid test that will cause parsing to take place and create 3 script_items */
281 cInChars = (sizeof(TestItem4)/2)-1;
282 cMaxItems = 255;
283 hr = ScriptItemize(TestItem4, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
284 ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
285 if (hr == 0)
286 {
287 ok (pcItems == 3, "The number of SCRIPT_ITEMS should be 3 not %d\n", pcItems);
288 if (pcItems > 2)
289 {
290 ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == 6,
291 "Start pos [0] not = 0 (%d) or end pos [1] not = %d\n",
292 pItem[0].iCharPos, pItem[1].iCharPos);
293 ok (pItem[1].iCharPos == 6 && pItem[2].iCharPos == 11,
294 "Start pos [1] not = 6 (%d) or end pos [2] not = 11 (%d)\n",
295 pItem[1].iCharPos, pItem[2].iCharPos);
296 ok (pItem[2].iCharPos == 11 && pItem[3].iCharPos == cInChars,
297 "Start pos [2] not = 11 (%d) or end [3] pos not = 14 (%d), cInChars = %d\n",
298 pItem[2].iCharPos, pItem[3].iCharPos, cInChars);
299 }
300 hr = ScriptFreeCache( &psc);
301 ok (!psc, "psc is not null after ScriptFreeCache\n");
302 }
303
304 /*
305 * This test is for when the first unicode character requires bidi support
306 */
307 cInChars = (sizeof(TestItem5)-1)/sizeof(WCHAR);
308 hr = ScriptItemize(TestItem5, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
309 ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
310 ok (pcItems == 4, "There should have been 4 items, found %d\n", pcItems);
311 ok (pItem[0].a.s.uBidiLevel == 1, "The first character should have been bidi=1 not %d\n",
312 pItem[0].a.s.uBidiLevel);
313 }
314
315 static void test_ScriptGetCMap(HDC hdc, unsigned short pwOutGlyphs[256])
316 {
317 HRESULT hr;
318 SCRIPT_CACHE psc = NULL;
319 int cInChars;
320 int cChars;
321 unsigned short pwOutGlyphs3[256];
322 WCHAR TestItem1[] = {'T', 'e', 's', 't', 'a', 0};
323 DWORD dwFlags;
324 int cnt;
325
326 /* Check to make sure that SCRIPT_CACHE gets allocated ok */
327 dwFlags = 0;
328 cInChars = cChars = 5;
329 /* Some sanity checks for ScriptGetCMap */
330
331 hr = ScriptGetCMap(NULL, NULL, NULL, 0, 0, NULL);
332 ok( hr == E_INVALIDARG, "(NULL,NULL,NULL,0,0,NULL), "
333 "expected E_INVALIDARG, got %08x\n", hr);
334
335 hr = ScriptGetCMap(NULL, NULL, TestItem1, cInChars, dwFlags, pwOutGlyphs3);
336 ok( hr == E_INVALIDARG, "(NULL,NULL,TestItem1, cInChars, dwFlags, pwOutGlyphs3), "
337 "expected E_INVALIDARG, got %08x\n", hr);
338
339 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
340 psc = NULL;
341 hr = ScriptGetCMap(NULL, &psc, TestItem1, cInChars, 0, pwOutGlyphs3);
342 ok( hr == E_PENDING, "(NULL,&psc,NULL,0,0,NULL), expected E_PENDING, "
343 "got %08x\n", hr);
344 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
345
346 /* Set psc to NULL but add hdc, to be able to check if a pointer is returned in psc */
347 psc = NULL;
348 hr = ScriptGetCMap(hdc, &psc, TestItem1, cInChars, 0, pwOutGlyphs3);
349 ok( hr == S_OK, "ScriptGetCMap(NULL,&psc,NULL,0,0,NULL), expected S_OK, "
350 "got %08x\n", hr);
351 ok( psc != NULL, "ScritpGetCMap expected psc to be not NULL\n");
352 ScriptFreeCache( &psc);
353
354 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
355 psc = NULL;
356 hr = ScriptGetCMap(NULL, &psc, TestItem1, cInChars, dwFlags, pwOutGlyphs3);
357 ok( hr == E_PENDING, "(NULL,&psc,), expected E_PENDING, got %08x\n", hr);
358 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
359 /* Check to see if the results are the same as those returned by ScriptShape */
360 hr = ScriptGetCMap(hdc, &psc, TestItem1, cInChars, dwFlags, pwOutGlyphs3);
361 ok (hr == 0, "ScriptGetCMap should return 0 not (%08x)\n", hr);
362 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
363 for (cnt=0; cnt < cChars && pwOutGlyphs[cnt] == pwOutGlyphs3[cnt]; cnt++) {}
364 ok (cnt == cInChars, "Translation not correct. WCHAR %d - %04x != %04x\n",
365 cnt, pwOutGlyphs[cnt], pwOutGlyphs3[cnt]);
366
367 hr = ScriptFreeCache( &psc);
368 ok (!psc, "psc is not null after ScriptFreeCache\n");
369
370 }
371
372 static void test_ScriptGetFontProperties(HDC hdc)
373 {
374 HRESULT hr;
375 SCRIPT_CACHE psc,old_psc;
376 SCRIPT_FONTPROPERTIES sfp;
377
378 /* Some sanity checks for ScriptGetFontProperties */
379
380 hr = ScriptGetFontProperties(NULL,NULL,NULL);
381 ok( hr == E_INVALIDARG, "(NULL,NULL,NULL), expected E_INVALIDARG, got %08x\n", hr);
382
383 hr = ScriptGetFontProperties(NULL,NULL,&sfp);
384 ok( hr == E_INVALIDARG, "(NULL,NULL,&sfp), expected E_INVALIDARG, got %08x\n", hr);
385
386 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
387 psc = NULL;
388 hr = ScriptGetFontProperties(NULL,&psc,NULL);
389 ok( hr == E_INVALIDARG, "(NULL,&psc,NULL), expected E_INVALIDARG, got %08x\n", hr);
390 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
391
392 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
393 psc = NULL;
394 hr = ScriptGetFontProperties(NULL,&psc,&sfp);
395 ok( hr == E_PENDING, "(NULL,&psc,&sfp), expected E_PENDING, got %08x\n", hr);
396 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
397
398 hr = ScriptGetFontProperties(hdc,NULL,NULL);
399 ok( hr == E_INVALIDARG, "(hdc,NULL,NULL), expected E_INVALIDARG, got %08x\n", hr);
400
401 hr = ScriptGetFontProperties(hdc,NULL,&sfp);
402 ok( hr == E_INVALIDARG, "(hdc,NULL,&sfp), expected E_INVALIDARG, got %08x\n", hr);
403
404 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
405 psc = NULL;
406 hr = ScriptGetFontProperties(hdc,&psc,NULL);
407 ok( hr == E_INVALIDARG, "(hdc,&psc,NULL), expected E_INVALIDARG, got %08x\n", hr);
408 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
409
410 /* Pass an invalid sfp */
411 psc = NULL;
412 sfp.cBytes = sizeof(SCRIPT_FONTPROPERTIES) - 1;
413 hr = ScriptGetFontProperties(hdc,&psc,&sfp);
414 ok( hr == E_INVALIDARG, "(hdc,&psc,&sfp) invalid, expected E_INVALIDARG, got %08x\n", hr);
415 ok( psc != NULL, "Expected a pointer in psc, got NULL\n");
416 ScriptFreeCache(&psc);
417 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
418
419 /* Give it the correct cBytes, we don't care about what's coming back */
420 sfp.cBytes = sizeof(SCRIPT_FONTPROPERTIES);
421 psc = NULL;
422 hr = ScriptGetFontProperties(hdc,&psc,&sfp);
423 ok( hr == S_OK, "(hdc,&psc,&sfp) partly initialized, expected S_OK, got %08x\n", hr);
424 ok( psc != NULL, "Expected a pointer in psc, got NULL\n");
425
426 /* Save the psc pointer */
427 old_psc = psc;
428 /* Now a NULL hdc again */
429 hr = ScriptGetFontProperties(NULL,&psc,&sfp);
430 ok( hr == S_OK, "(NULL,&psc,&sfp), expected S_OK, got %08x\n", hr);
431 ok( psc == old_psc, "Expected psc not to be changed, was %p is now %p\n", old_psc, psc);
432 ScriptFreeCache(&psc);
433 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
434 }
435
436 static void test_ScriptTextOut(HDC hdc)
437 {
438 HRESULT hr;
439
440 int cInChars;
441 int cMaxItems;
442 SCRIPT_ITEM pItem[255];
443 int pcItems;
444 WCHAR TestItem1[] = {'T', 'e', 's', 't', 'a', 0};
445
446 SCRIPT_CACHE psc;
447 int cChars;
448 int cMaxGlyphs;
449 unsigned short pwOutGlyphs1[256];
450 WORD pwLogClust[256];
451 SCRIPT_VISATTR psva[256];
452 int pcGlyphs;
453 int piAdvance[256];
454 GOFFSET pGoffset[256];
455 ABC pABC[256];
456 RECT rect;
457 int piX;
458 int iCP = 1;
459 BOOL fTrailing = FALSE;
460 SCRIPT_LOGATTR *psla;
461 SCRIPT_LOGATTR sla[256];
462
463 /* This is a valid test that will cause parsing to take place */
464 cInChars = 5;
465 cMaxItems = 255;
466 hr = ScriptItemize(TestItem1, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
467 ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
468 /* This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
469 * returned. */
470 ok (pcItems > 0, "The number of SCRIPT_ITEMS should be greater than 0\n");
471 if (pcItems > 0)
472 ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == cInChars,
473 "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
474 pItem[0].iCharPos, cInChars, pItem[1].iCharPos);
475
476 /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue
477 * ie. ScriptItemize has succeeded and that pItem has been set */
478 cInChars = 5;
479 cMaxItems = 255;
480 if (hr == 0) {
481 psc = NULL; /* must be null on first call */
482 cChars = cInChars;
483 cMaxGlyphs = cInChars;
484 cMaxGlyphs = 256;
485 hr = ScriptShape(hdc, &psc, TestItem1, cChars,
486 cMaxGlyphs, &pItem[0].a,
487 pwOutGlyphs1, pwLogClust, psva, &pcGlyphs);
488 ok (hr == 0, "ScriptShape should return 0 not (%08x)\n", hr);
489 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
490 ok (pcGlyphs == cChars, "Chars in (%d) should equal Glyphs out (%d)\n", cChars, pcGlyphs);
491 if (hr ==0) {
492 /* Note hdc is needed as glyph info is not yet in psc */
493 hr = ScriptPlace(hdc, &psc, pwOutGlyphs1, pcGlyphs, psva, &pItem[0].a, piAdvance,
494 pGoffset, pABC);
495 ok (hr == 0, "Should return 0 not (%08x)\n", hr);
496 ScriptFreeCache(&psc); /* Get rid of psc for next test set */
497 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
498
499 hr = ScriptTextOut(NULL, NULL, 0, 0, 0, NULL, NULL, NULL, 0, NULL, 0, NULL, NULL, NULL);
500 ok (hr == E_INVALIDARG, "Should return 0 not (%08x)\n", hr);
501
502 hr = ScriptTextOut(NULL, NULL, 0, 0, 0, NULL, &pItem[0].a, NULL, 0, pwOutGlyphs1, pcGlyphs,
503 piAdvance, NULL, pGoffset);
504 ok( hr == E_INVALIDARG, "(NULL,NULL,TestItem1, cInChars, dwFlags, pwOutGlyphs3), "
505 "expected E_INVALIDARG, got %08x\n", hr);
506
507 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
508 psc = NULL;
509 hr = ScriptTextOut(NULL, &psc, 0, 0, 0, NULL, NULL, NULL, 0, NULL, 0,
510 NULL, NULL, NULL);
511 ok( hr == E_INVALIDARG, "(NULL,&psc,NULL,0,0,0,NULL,), expected E_INVALIDARG, "
512 "got %08x\n", hr);
513 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
514
515 /* hdc is required for this one rather than the usual optional */
516 psc = NULL;
517 hr = ScriptTextOut(NULL, &psc, 0, 0, 0, NULL, &pItem[0].a, NULL, 0, pwOutGlyphs1, pcGlyphs,
518 piAdvance, NULL, pGoffset);
519 ok( hr == E_INVALIDARG, "(NULL,&psc,), expected E_INVALIDARG, got %08x\n", hr);
520 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
521
522 /* Set that it returns 0 status */
523 hr = ScriptTextOut(hdc, &psc, 0, 0, 0, NULL, &pItem[0].a, NULL, 0, pwOutGlyphs1, pcGlyphs,
524 piAdvance, NULL, pGoffset);
525 ok (hr == 0, "ScriptTextOut should return 0 not (%08x)\n", hr);
526
527 /* Test Rect Rgn is acceptable */
528 rect.top = 10;
529 rect.bottom = 20;
530 rect.left = 10;
531 rect.right = 40;
532 hr = ScriptTextOut(hdc, &psc, 0, 0, 0, &rect, &pItem[0].a, NULL, 0, pwOutGlyphs1, pcGlyphs,
533 piAdvance, NULL, pGoffset);
534 ok (hr == 0, "ScriptTextOut should return 0 not (%08x)\n", hr);
535
536 iCP = 1;
537 hr = ScriptCPtoX(iCP, fTrailing, cChars, pcGlyphs, (const WORD *) &pwLogClust,
538 (const SCRIPT_VISATTR *) &psva, (const int *)&piAdvance, &pItem[0].a, &piX);
539 ok(hr == S_OK, "ScriptCPtoX Stub should return S_OK not %08x\n", hr);
540
541 psla = (SCRIPT_LOGATTR *)&sla;
542 hr = ScriptBreak(TestItem1, cChars, &pItem[0].a, psla);
543 ok(hr == S_OK, "ScriptBreak Stub should return S_OK not %08x\n", hr);
544
545 /* Clean up and go */
546 ScriptFreeCache(&psc);
547 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
548 }
549 }
550 }
551
552 static void test_ScriptTextOut2(HDC hdc)
553 {
554 /* Intent is to validate that the HDC passed into ScriptTextOut is
555 * used instead of the (possibly) invalid cached one
556 */
557 HRESULT hr;
558
559 HDC hdc1, hdc2;
560 int cInChars;
561 int cMaxItems;
562 SCRIPT_ITEM pItem[255];
563 int pcItems;
564 WCHAR TestItem1[] = {'T', 'e', 's', 't', 'a', 0};
565
566 SCRIPT_CACHE psc;
567 int cChars;
568 int cMaxGlyphs;
569 unsigned short pwOutGlyphs1[256];
570 WORD pwLogClust[256];
571 SCRIPT_VISATTR psva[256];
572 int pcGlyphs;
573 int piAdvance[256];
574 GOFFSET pGoffset[256];
575 ABC pABC[256];
576
577 /* Create an extra DC that will be used until the ScriptTextOut */
578 hdc1 = CreateCompatibleDC(hdc);
579 ok (hdc1 != 0, "CreateCompatibleDC failed to create a DC\n");
580 hdc2 = CreateCompatibleDC(hdc);
581 ok (hdc2 != 0, "CreateCompatibleDC failed to create a DC\n");
582
583 /* This is a valid test that will cause parsing to take place */
584 cInChars = 5;
585 cMaxItems = 255;
586 hr = ScriptItemize(TestItem1, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
587 ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
588 /* This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
589 * returned. */
590 ok (pcItems > 0, "The number of SCRIPT_ITEMS should be greater than 0\n");
591 if (pcItems > 0)
592 ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == cInChars,
593 "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
594 pItem[0].iCharPos, cInChars, pItem[1].iCharPos);
595
596 /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue
597 * ie. ScriptItemize has succeeded and that pItem has been set */
598 cInChars = 5;
599 cMaxItems = 255;
600 if (hr == 0) {
601 psc = NULL; /* must be null on first call */
602 cChars = cInChars;
603 cMaxGlyphs = cInChars;
604 cMaxGlyphs = 256;
605 hr = ScriptShape(hdc2, &psc, TestItem1, cChars,
606 cMaxGlyphs, &pItem[0].a,
607 pwOutGlyphs1, pwLogClust, psva, &pcGlyphs);
608 ok (hr == 0, "ScriptShape should return 0 not (%08x)\n", hr);
609 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
610 ok (pcGlyphs == cChars, "Chars in (%d) should equal Glyphs out (%d)\n", cChars, pcGlyphs);
611 if (hr ==0) {
612 /* Note hdc is needed as glyph info is not yet in psc */
613 hr = ScriptPlace(hdc2, &psc, pwOutGlyphs1, pcGlyphs, psva, &pItem[0].a, piAdvance,
614 pGoffset, pABC);
615 ok (hr == 0, "Should return 0 not (%08x)\n", hr);
616
617 /* key part!!! cached dc is being deleted */
618 hr = DeleteDC(hdc2);
619 ok(hr == 1, "DeleteDC should return 1 not %08x\n", hr);
620
621 /* At this point the cached hdc (hdc2) has been destroyed,
622 * however, we are passing in a *real* hdc (the original hdc).
623 * The text should be written to that DC
624 */
625 hr = ScriptTextOut(hdc1, &psc, 0, 0, 0, NULL, &pItem[0].a, NULL, 0, pwOutGlyphs1, pcGlyphs,
626 piAdvance, NULL, pGoffset);
627 ok (hr == 0, "ScriptTextOut should return 0 not (%08x)\n", hr);
628 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
629
630 DeleteDC(hdc1);
631
632 /* Clean up and go */
633 ScriptFreeCache(&psc);
634 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
635 }
636 }
637 }
638
639 static void test_ScriptXtoX(void)
640 /****************************************************************************************
641 * This routine tests the ScriptXtoCP and ScriptCPtoX functions using static variables *
642 ****************************************************************************************/
643 {
644 static const WCHAR test[] = {'t', 'e', 's', 't',0};
645 SCRIPT_ITEM items[2];
646 int iX, iCP;
647 int cChars;
648 int cGlyphs;
649 WORD pwLogClust[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
650 SCRIPT_VISATTR psva[10];
651 int piAdvance[10] = {200, 190, 210, 180, 170, 204, 189, 195, 212, 203};
652 int piCP, piX;
653 int piTrailing;
654 BOOL fTrailing;
655 HRESULT hr;
656
657 hr = ScriptItemize(test, lstrlenW(test), sizeof(items)/sizeof(items[0]), NULL, NULL, items, NULL);
658 ok(!hr, "ScriptItemize should return S_OK not %08x\n", hr);
659
660 iX = -1;
661 cChars = 10;
662 cGlyphs = 10;
663 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
664 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
665 if (piTrailing)
666 ok(piCP == -1, "Negative iX should return piCP=-1 not %d\n", piCP);
667 else /* win2k3 */
668 ok(piCP == 10, "Negative iX should return piCP=10 not %d\n", piCP);
669
670 iX = 1954;
671 cChars = 10;
672 cGlyphs = 10;
673 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
674 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
675 if (piTrailing) /* win2k3 */
676 ok(piCP == -1, "Negative iX should return piCP=-1 not %d\n", piCP);
677 else
678 ok(piCP == 10, "Negative iX should return piCP=10 not %d\n", piCP);
679
680 iX = 779;
681 cChars = 10;
682 cGlyphs = 10;
683 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
684 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
685 ok(piCP == 3 ||
686 piCP == -1, /* win2k3 */
687 "iX=%d should return piCP=3 or piCP=-1 not %d\n", iX, piCP);
688 ok(piTrailing == 1, "iX=%d should return piTrailing=1 not %d\n", iX, piTrailing);
689
690 iX = 780;
691 cChars = 10;
692 cGlyphs = 10;
693 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
694 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
695 ok(piCP == 3 ||
696 piCP == -1, /* win2k3 */
697 "iX=%d should return piCP=3 or piCP=-1 not %d\n", iX, piCP);
698 ok(piTrailing == 1, "iX=%d should return piTrailing=1 not %d\n", iX, piTrailing);
699
700 iX = 868;
701 cChars = 10;
702 cGlyphs = 10;
703 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
704 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
705 ok(piCP == 4 ||
706 piCP == -1, /* win2k3 */
707 "iX=%d should return piCP=4 or piCP=-1 not %d\n", iX, piCP);
708
709 iX = 0;
710 cChars = 10;
711 cGlyphs = 10;
712 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
713 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
714 ok(piCP == 0 ||
715 piCP == 10, /* win2k3 */
716 "iX=%d should return piCP=0 piCP=10 not %d\n", iX, piCP);
717
718 iX = 195;
719 cChars = 10;
720 cGlyphs = 10;
721 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
722 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
723 ok(piCP == 0, "iX=%d should return piCP=0 not %d\n", iX, piCP);
724
725 iX = 196;
726 cChars = 10;
727 cGlyphs = 10;
728 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
729 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
730 ok(piCP == 1 ||
731 piCP == 0, /* win2k3 */
732 "iX=%d should return piCP=1 or piCP=0 not %d\n", iX, piCP);
733
734 iCP=5;
735 fTrailing = FALSE;
736 cChars = 10;
737 cGlyphs = 10;
738 hr = ScriptCPtoX(iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piX);
739 ok(hr == S_OK, "ScriptCPtoX should return S_OK not %08x\n", hr);
740 ok(piX == 976 ||
741 piX == 100, /* win2k3 */
742 "iCP=%d should return piX=976 or piX=100 not %d\n", iCP, piX);
743
744 iCP=5;
745 fTrailing = TRUE;
746 cChars = 10;
747 cGlyphs = 10;
748 hr = ScriptCPtoX(iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piX);
749 ok(hr == S_OK, "ScriptCPtoX should return S_OK not %08x\n", hr);
750 ok(piX == 1171 ||
751 piX == 80, /* win2k3 */
752 "iCP=%d should return piX=1171 or piX=80 not %d\n", iCP, piX);
753
754 iCP=6;
755 fTrailing = FALSE;
756 cChars = 10;
757 cGlyphs = 10;
758 hr = ScriptCPtoX(iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piX);
759 ok(hr == S_OK, "ScriptCPtoX should return S_OK not %08x\n", hr);
760 ok(piX == 1171 ||
761 piX == 80, /* win2k3 */
762 "iCP=%d should return piX=1171 or piX=80 not %d\n", iCP, piX);
763
764 iCP=11;
765 fTrailing = FALSE;
766 cChars = 10;
767 cGlyphs = 10;
768 hr = ScriptCPtoX(iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piX);
769 ok(hr == S_OK, "ScriptCPtoX should return S_OK not %08x\n", hr);
770 ok(piX == 1953 ||
771 piX == 0, /* win2k3 */
772 "iCP=%d should return piX=1953 or piX=0 not %d\n", iCP, piX);
773
774 iCP=11;
775 fTrailing = TRUE;
776 cChars = 10;
777 cGlyphs = 10;
778 hr = ScriptCPtoX(iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piX);
779 ok(hr == S_OK, "ScriptCPtoX should return S_OK not %08x\n", hr);
780 ok(piX == 1953 ||
781 piX == 0, /* win2k3 */
782 "iCP=%d should return piX=1953 or piX=0 not %d\n", iCP, piX);
783 }
784
785 static void test_ScriptString(HDC hdc)
786 {
787 /*******************************************************************************************
788 *
789 * This set of tests are for the string functions of uniscribe. The ScriptStringAnalyse
790 * function allocates memory pointed to by the SCRIPT_STRING_ANALYSIS ssa pointer. This
791 * memory if freed by ScriptStringFree. There needs to be a valid hdc for this as
792 * ScriptStringAnalyse calls ScriptSItemize, ScriptShape and ScriptPlace which require it.
793 *
794 */
795
796 HRESULT hr;
797 WCHAR teststr[] = {'T','e','s','t','1',' ','a','2','b','3', '\0'};
798 int len = (sizeof(teststr) / sizeof(WCHAR)) - 1;
799 int Glyphs = len * 2 + 16;
800 int Charset;
801 DWORD Flags = SSA_GLYPHS;
802 int ReqWidth = 100;
803 SCRIPT_CONTROL Control;
804 SCRIPT_STATE State;
805 const int Dx[5] = {10, 10, 10, 10, 10};
806 SCRIPT_TABDEF Tabdef;
807 const BYTE InClass = 0;
808 SCRIPT_STRING_ANALYSIS ssa = NULL;
809
810 int X = 10;
811 int Y = 100;
812 UINT Options = 0;
813 const RECT rc = {0, 50, 100, 100};
814 int MinSel = 0;
815 int MaxSel = 0;
816 BOOL Disabled = FALSE;
817 const int *clip_len;
818 int i;
819 UINT *order;
820
821
822 Charset = -1; /* this flag indicates unicode input */
823 /* Test without hdc to get E_PENDING */
824 hr = ScriptStringAnalyse( NULL, teststr, len, Glyphs, Charset, Flags,
825 ReqWidth, &Control, &State, Dx, &Tabdef,
826 &InClass, &ssa);
827 ok(hr == E_PENDING, "ScriptStringAnalyse Stub should return E_PENDING not %08x\n", hr);
828
829 /* test with hdc, this should be a valid test */
830 hr = ScriptStringAnalyse( hdc, teststr, len, Glyphs, Charset, Flags,
831 ReqWidth, &Control, &State, Dx, &Tabdef,
832 &InClass, &ssa);
833 ok(hr == S_OK, "ScriptStringAnalyse should return S_OK not %08x\n", hr);
834 ScriptStringFree(&ssa);
835
836 /* test makes sure that a call with a valid pssa still works */
837 hr = ScriptStringAnalyse( hdc, teststr, len, Glyphs, Charset, Flags,
838 ReqWidth, &Control, &State, Dx, &Tabdef,
839 &InClass, &ssa);
840 ok(hr == S_OK, "ScriptStringAnalyse should return S_OK not %08x\n", hr);
841 ok(ssa != NULL, "ScriptStringAnalyse pssa should not be NULL\n");
842
843 if (hr == S_OK)
844 {
845 hr = ScriptStringOut(ssa, X, Y, Options, &rc, MinSel, MaxSel, Disabled);
846 ok(hr == S_OK, "ScriptStringOut should return S_OK not %08x\n", hr);
847 }
848
849 clip_len = ScriptString_pcOutChars(ssa);
850 ok(*clip_len == len, "ScriptString_pcOutChars failed, got %d, expected %d\n", *clip_len, len);
851
852 order = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *clip_len * sizeof(UINT));
853 hr = ScriptStringGetOrder(ssa, order);
854 ok(hr == S_OK, "ScriptStringGetOrder failed, got %08x, expected S_OK\n", hr);
855
856 for (i = 0; i < *clip_len; i++) ok(order[i] == i, "%d: got %d expected %d\n", i, order[i], i);
857 HeapFree(GetProcessHeap(), 0, order);
858
859 hr = ScriptStringFree(&ssa);
860 ok(hr == S_OK, "ScriptStringFree should return S_OK not %08x\n", hr);
861 }
862
863 static void test_ScriptStringXtoCP_CPtoX(HDC hdc)
864 {
865 /*****************************************************************************************
866 *
867 * This test is for the ScriptStringXtoCP and ScriptStringXtoCP functions. Due to the
868 * nature of the fonts between Windows and Wine, the test is implemented by generating
869 * values using one one function then checking the output of the second. In this way
870 * the validity of the functions is established using Windows as a base and confirming
871 * similar behaviour in wine.
872 */
873
874 HRESULT hr;
875 WCHAR teststr1[] = {'T', 'e', 's', 't', 'e', '1', '2', ' ', 'a', '\0'};
876 void *String = (WCHAR *) &teststr1; /* ScriptStringAnalysis needs void */
877 int String_len = (sizeof(teststr1)/sizeof(WCHAR))-1;
878 int Glyphs = String_len * 2 + 16; /* size of buffer as recommended */
879 int Charset = -1; /* unicode */
880 DWORD Flags = SSA_GLYPHS;
881 int ReqWidth = 100;
882 SCRIPT_CONTROL Control;
883 SCRIPT_STATE State;
884 SCRIPT_TABDEF Tabdef;
885 const BYTE InClass = 0;
886 SCRIPT_STRING_ANALYSIS ssa = NULL;
887
888 int Ch; /* Character position in string */
889 int iTrailing;
890 int Cp; /* Character position in string */
891 int X;
892 BOOL fTrailing;
893
894 /* Test with hdc, this should be a valid test
895 * Here we generate an SCRIPT_STRING_ANALYSIS that will be used as input to the
896 * following character positions to X and X to character position functions.
897 */
898 hr = ScriptStringAnalyse( hdc, String, String_len, Glyphs, Charset, Flags,
899 ReqWidth, &Control, &State, NULL, &Tabdef,
900 &InClass, &ssa);
901 ok(hr == S_OK ||
902 hr == E_INVALIDARG, /* NT */
903 "ScriptStringAnalyse should return S_OK or E_INVALIDARG not %08x\n", hr);
904
905 if (hr == S_OK)
906 {
907 ok(ssa != NULL, "ScriptStringAnalyse ssa should not be NULL\n");
908
909 /*
910 * Loop to generate character positions to provide starting positions for the
911 * ScriptStringCPtoX and ScriptStringXtoCP functions
912 */
913 for (Cp = 0; Cp < String_len; Cp++)
914 {
915 /* The fTrailing flag is used to indicate whether the X being returned is at
916 * the beginning or the end of the character. What happens here is that if
917 * fTrailing indicates the end of the character, ie. FALSE, then ScriptStringXtoCP
918 * returns the beginning of the next character and iTrailing is FALSE. So for this
919 * loop iTrailing will be FALSE in both cases.
920 */
921 fTrailing = FALSE;
922 hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
923 ok(hr == S_OK, "ScriptStringCPtoX should return S_OK not %08x\n", hr);
924 hr = ScriptStringXtoCP(ssa, X, &Ch, &iTrailing);
925 ok(hr == S_OK, "ScriptStringXtoCP should return S_OK not %08x\n", hr);
926 ok(Cp == Ch, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp, Ch, X);
927 ok(iTrailing == FALSE, "ScriptStringXtoCP should return iTrailing = 0 not %d for X = %d\n",
928 iTrailing, X);
929 fTrailing = TRUE;
930 hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
931 ok(hr == S_OK, "ScriptStringCPtoX should return S_OK not %08x\n", hr);
932 hr = ScriptStringXtoCP(ssa, X, &Ch, &iTrailing);
933 ok(hr == S_OK, "ScriptStringXtoCP should return S_OK not %08x\n", hr);
934
935 /*
936 * Check that character position returned by ScriptStringXtoCP in Ch matches the
937 * one input to ScriptStringCPtoX. This means that the Cp to X position and back
938 * again works
939 */
940 ok(Cp + 1 == Ch, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp + 1, Ch, X);
941 ok(iTrailing == FALSE, "ScriptStringXtoCP should return iTrailing = 0 not %d for X = %d\n",
942 iTrailing, X);
943 }
944 /*
945 * This test is to check that if the X position is just inside the trailing edge of the
946 * character then iTrailing will indicate the trailing edge, ie. TRUE
947 */
948 fTrailing = TRUE;
949 Cp = 3;
950 hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
951 ok(hr == S_OK, "ScriptStringCPtoX should return S_OK not %08x\n", hr);
952 X--; /* put X just inside the trailing edge */
953 hr = ScriptStringXtoCP(ssa, X, &Ch, &iTrailing);
954 ok(hr == S_OK, "ScriptStringXtoCP should return S_OK not %08x\n", hr);
955 ok(Cp == Ch, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp, Ch, X);
956 ok(iTrailing == TRUE, "ScriptStringXtoCP should return iTrailing = 1 not %d for X = %d\n",
957 iTrailing, X);
958
959 /*
960 * This test is to check that if the X position is just outside the trailing edge of the
961 * character then iTrailing will indicate the leading edge, ie. FALSE, and Ch will indicate
962 * the next character, ie. Cp + 1
963 */
964 fTrailing = TRUE;
965 Cp = 3;
966 hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
967 ok(hr == S_OK, "ScriptStringCPtoX should return S_OK not %08x\n", hr);
968 X++; /* put X just outside the trailing edge */
969 hr = ScriptStringXtoCP(ssa, X, &Ch, &iTrailing);
970 ok(hr == S_OK, "ScriptStringXtoCP should return S_OK not %08x\n", hr);
971 ok(Cp + 1 == Ch, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp + 1, Ch, X);
972 ok(iTrailing == FALSE, "ScriptStringXtoCP should return iTrailing = 0 not %d for X = %d\n",
973 iTrailing, X);
974
975 /*
976 * This test is to check that if the X position is just outside the leading edge of the
977 * character then iTrailing will indicate the trailing edge, ie. TRUE, and Ch will indicate
978 * the next character down , ie. Cp - 1
979 */
980 fTrailing = FALSE;
981 Cp = 3;
982 hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
983 ok(hr == S_OK, "ScriptStringCPtoX should return S_OK not %08x\n", hr);
984 X--; /* put X just outside the leading edge */
985 hr = ScriptStringXtoCP(ssa, X, &Ch, &iTrailing);
986 ok(hr == S_OK, "ScriptStringXtoCP should return S_OK not %08x\n", hr);
987 ok(Cp - 1 == Ch, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp - 1, Ch, X);
988 ok(iTrailing == TRUE, "ScriptStringXtoCP should return iTrailing = 1 not %d for X = %d\n",
989 iTrailing, X);
990
991 /*
992 * Cleanup the SSA for the next round of tests
993 */
994 hr = ScriptStringFree(&ssa);
995 ok(hr == S_OK, "ScriptStringFree should return S_OK not %08x\n", hr);
996
997 /*
998 * Test to see that exceeding the number of chars returns E_INVALIDARG. First
999 * generate an SSA for the subsequent tests.
1000 */
1001 hr = ScriptStringAnalyse( hdc, String, String_len, Glyphs, Charset, Flags,
1002 ReqWidth, &Control, &State, NULL, &Tabdef,
1003 &InClass, &ssa);
1004 ok(hr == S_OK, "ScriptStringAnalyse should return S_OK not %08x\n", hr);
1005
1006 /*
1007 * When ScriptStringCPtoX is called with a character position Cp that exceeds the
1008 * string length, return E_INVALIDARG. This also invalidates the ssa so a
1009 * ScriptStringFree should also fail.
1010 */
1011 fTrailing = FALSE;
1012 Cp = String_len + 1;
1013 hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
1014 ok(hr == E_INVALIDARG, "ScriptStringCPtoX should return E_INVALIDARG not %08x\n", hr);
1015
1016 hr = ScriptStringFree(&ssa);
1017 /*
1018 * ScriptStringCPtoX should free ssa, hence ScriptStringFree should fail
1019 */
1020 ok(hr == E_INVALIDARG ||
1021 hr == E_FAIL, /* win2k3 */
1022 "ScriptStringFree should return E_INVALIDARG or E_FAIL not %08x\n", hr);
1023 }
1024 }
1025
1026 static void test_ScriptCacheGetHeight(HDC hdc)
1027 {
1028 HRESULT hr;
1029 SCRIPT_CACHE sc = NULL;
1030 LONG height;
1031
1032 hr = ScriptCacheGetHeight(NULL, NULL, NULL);
1033 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
1034
1035 hr = ScriptCacheGetHeight(NULL, &sc, NULL);
1036 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
1037
1038 hr = ScriptCacheGetHeight(NULL, &sc, &height);
1039 ok(hr == E_PENDING, "expected E_PENDING, got 0x%08x\n", hr);
1040
1041 height = 0;
1042
1043 hr = ScriptCacheGetHeight(hdc, &sc, &height);
1044 ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
1045 ok(height > 0, "expected height > 0\n");
1046
1047 ScriptFreeCache(&sc);
1048 }
1049
1050 static void test_ScriptGetGlyphABCWidth(HDC hdc)
1051 {
1052 HRESULT hr;
1053 SCRIPT_CACHE sc = NULL;
1054 ABC abc;
1055
1056 hr = ScriptGetGlyphABCWidth(NULL, NULL, 'a', NULL);
1057 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
1058
1059 hr = ScriptGetGlyphABCWidth(NULL, &sc, 'a', NULL);
1060 ok(broken(hr == E_PENDING) ||
1061 hr == E_INVALIDARG, /* WIN7 */
1062 "expected E_INVALIDARG, got 0x%08x\n", hr);
1063
1064 hr = ScriptGetGlyphABCWidth(NULL, &sc, 'a', &abc);
1065 ok(hr == E_PENDING, "expected E_PENDING, got 0x%08x\n", hr);
1066
1067 if (0) { /* crashes on WinXP */
1068 hr = ScriptGetGlyphABCWidth(hdc, &sc, 'a', NULL);
1069 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
1070 }
1071
1072 hr = ScriptGetGlyphABCWidth(hdc, &sc, 'a', &abc);
1073 ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
1074
1075 ScriptFreeCache(&sc);
1076 }
1077
1078 static void test_ScriptLayout(void)
1079 {
1080 HRESULT hr;
1081 static const BYTE levels[][5] =
1082 {
1083 { 0, 0, 0, 0, 0 },
1084 { 1, 1, 1, 1, 1 },
1085 { 2, 2, 2, 2, 2 },
1086 { 3, 3, 3, 3, 3 },
1087 };
1088 static const int expect[][5] =
1089 {
1090 { 0, 1, 2, 3, 4 },
1091 { 4, 3, 2, 1, 0 },
1092 { 0, 1, 2, 3, 4 },
1093 { 4, 3, 2, 1, 0 }
1094 };
1095 int i, j, vistolog[sizeof(levels[0])], logtovis[sizeof(levels[0])];
1096
1097 hr = ScriptLayout(sizeof(levels[0]), NULL, vistolog, logtovis);
1098 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
1099
1100 hr = ScriptLayout(sizeof(levels[0]), levels[0], NULL, NULL);
1101 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
1102
1103 for (i = 0; i < sizeof(levels)/sizeof(levels[0]); i++)
1104 {
1105 hr = ScriptLayout(sizeof(levels[0]), levels[i], vistolog, logtovis);
1106 ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
1107
1108 for (j = 0; j < sizeof(levels[i]); j++)
1109 {
1110 ok(expect[i][j] == vistolog[j],
1111 "failure: levels[%d][%d] = %d, vistolog[%d] = %d\n",
1112 i, j, levels[i][j], j, vistolog[j] );
1113 }
1114
1115 for (j = 0; j < sizeof(levels[i]); j++)
1116 {
1117 ok(expect[i][j] == logtovis[j],
1118 "failure: levels[%d][%d] = %d, logtovis[%d] = %d\n",
1119 i, j, levels[i][j], j, logtovis[j] );
1120 }
1121 }
1122 }
1123
1124 static BOOL CALLBACK enum_proc(LGRPID group, LCID lcid, LPSTR locale, LONG_PTR lparam)
1125 {
1126 HRESULT hr;
1127 SCRIPT_DIGITSUBSTITUTE sds;
1128 SCRIPT_CONTROL sc;
1129 SCRIPT_STATE ss;
1130 LCID lcid_old;
1131
1132 if (!IsValidLocale(lcid, LCID_INSTALLED)) return TRUE;
1133
1134 memset(&sds, 0, sizeof(sds));
1135 memset(&sc, 0, sizeof(sc));
1136 memset(&ss, 0, sizeof(ss));
1137
1138 lcid_old = GetThreadLocale();
1139 if (!SetThreadLocale(lcid)) return TRUE;
1140
1141 hr = ScriptRecordDigitSubstitution(lcid, &sds);
1142 ok(hr == S_OK, "ScriptRecordDigitSubstitution failed: 0x%08x\n", hr);
1143
1144 hr = ScriptApplyDigitSubstitution(&sds, &sc, &ss);
1145 ok(hr == S_OK, "ScriptApplyDigitSubstitution failed: 0x%08x\n", hr);
1146
1147 SetThreadLocale(lcid_old);
1148 return TRUE;
1149 }
1150
1151 static void test_digit_substitution(void)
1152 {
1153 BOOL ret;
1154 unsigned int i;
1155 static const LGRPID groups[] =
1156 {
1157 LGRPID_WESTERN_EUROPE,
1158 LGRPID_CENTRAL_EUROPE,
1159 LGRPID_BALTIC,
1160 LGRPID_GREEK,
1161 LGRPID_CYRILLIC,
1162 LGRPID_TURKISH,
1163 LGRPID_JAPANESE,
1164 LGRPID_KOREAN,
1165 LGRPID_TRADITIONAL_CHINESE,
1166 LGRPID_SIMPLIFIED_CHINESE,
1167 LGRPID_THAI,
1168 LGRPID_HEBREW,
1169 LGRPID_ARABIC,
1170 LGRPID_VIETNAMESE,
1171 LGRPID_INDIC,
1172 LGRPID_GEORGIAN,
1173 LGRPID_ARMENIAN
1174 };
1175 HMODULE hKernel32;
1176 static BOOL (WINAPI * pEnumLanguageGroupLocalesA)(LANGGROUPLOCALE_ENUMPROCA,LGRPID,DWORD,LONG_PTR);
1177
1178 hKernel32 = GetModuleHandleA("kernel32.dll");
1179 pEnumLanguageGroupLocalesA = (void*)GetProcAddress(hKernel32, "EnumLanguageGroupLocalesA");
1180
1181 if (!pEnumLanguageGroupLocalesA)
1182 {
1183 win_skip("EnumLanguageGroupLocalesA not available on this platform\n");
1184 return;
1185 }
1186
1187 for (i = 0; i < sizeof(groups)/sizeof(groups[0]); i++)
1188 {
1189 ret = pEnumLanguageGroupLocalesA(enum_proc, groups[i], 0, 0);
1190 if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1191 {
1192 win_skip("EnumLanguageGroupLocalesA not implemented on this platform\n");
1193 break;
1194 }
1195
1196 ok(ret, "EnumLanguageGroupLocalesA failed unexpectedly: %u\n", GetLastError());
1197 }
1198 }
1199
1200 static void test_ScriptGetProperties(void)
1201 {
1202 const SCRIPT_PROPERTIES **props;
1203 HRESULT hr;
1204 int num;
1205
1206 hr = ScriptGetProperties(NULL, NULL);
1207 ok(hr == E_INVALIDARG, "ScriptGetProperties succeeded\n");
1208
1209 hr = ScriptGetProperties(NULL, &num);
1210 ok(hr == S_OK, "ScriptGetProperties failed: 0x%08x\n", hr);
1211
1212 hr = ScriptGetProperties(&props, NULL);
1213 ok(hr == S_OK, "ScriptGetProperties failed: 0x%08x\n", hr);
1214
1215 hr = ScriptGetProperties(&props, &num);
1216 ok(hr == S_OK, "ScriptGetProperties failed: 0x%08x\n", hr);
1217 }
1218
1219 static void test_ScriptBreak(void)
1220 {
1221 static const WCHAR test[] = {' ','\r','\n',0};
1222 SCRIPT_ITEM items[4];
1223 SCRIPT_LOGATTR la;
1224 HRESULT hr;
1225
1226 hr = ScriptItemize(test, 3, 4, NULL, NULL, items, NULL);
1227 ok(!hr, "ScriptItemize should return S_OK not %08x\n", hr);
1228
1229 memset(&la, 0, sizeof(la));
1230 hr = ScriptBreak(test, 1, &items[0].a, &la);
1231 ok(!hr, "ScriptBreak should return S_OK not %08x\n", hr);
1232
1233 ok(!la.fSoftBreak, "fSoftBreak set\n");
1234 ok(la.fWhiteSpace, "fWhiteSpace not set\n");
1235 ok(la.fCharStop, "fCharStop not set\n");
1236 ok(!la.fWordStop, "fWordStop set\n");
1237 ok(!la.fInvalid, "fInvalid set\n");
1238 ok(!la.fReserved, "fReserved set\n");
1239
1240 memset(&la, 0, sizeof(la));
1241 hr = ScriptBreak(test + 1, 1, &items[1].a, &la);
1242 ok(!hr, "ScriptBreak should return S_OK not %08x\n", hr);
1243
1244 ok(!la.fSoftBreak, "fSoftBreak set\n");
1245 ok(!la.fWhiteSpace, "fWhiteSpace set\n");
1246 ok(la.fCharStop, "fCharStop not set\n");
1247 ok(!la.fWordStop, "fWordStop set\n");
1248 ok(!la.fInvalid, "fInvalid set\n");
1249 ok(!la.fReserved, "fReserved set\n");
1250
1251 memset(&la, 0, sizeof(la));
1252 hr = ScriptBreak(test + 2, 1, &items[2].a, &la);
1253 ok(!hr, "ScriptBreak should return S_OK not %08x\n", hr);
1254
1255 ok(!la.fSoftBreak, "fSoftBreak set\n");
1256 ok(!la.fWhiteSpace, "fWhiteSpace set\n");
1257 ok(la.fCharStop, "fCharStop not set\n");
1258 ok(!la.fWordStop, "fWordStop set\n");
1259 ok(!la.fInvalid, "fInvalid set\n");
1260 ok(!la.fReserved, "fReserved set\n");
1261 }
1262
1263 static void test_newlines(void)
1264 {
1265 static const WCHAR test1[] = {'t','e','x','t','\r','t','e','x','t',0};
1266 static const WCHAR test2[] = {'t','e','x','t','\n','t','e','x','t',0};
1267 static const WCHAR test3[] = {'t','e','x','t','\r','\n','t','e','x','t',0};
1268 static const WCHAR test4[] = {'t','e','x','t','\n','\r','t','e','x','t',0};
1269 static const WCHAR test5[] = {'1','2','3','4','\n','\r','1','2','3','4',0};
1270 SCRIPT_ITEM items[5];
1271 HRESULT hr;
1272 int count;
1273
1274 count = 0;
1275 hr = ScriptItemize(test1, lstrlenW(test1), 5, NULL, NULL, items, &count);
1276 ok(hr == S_OK, "ScriptItemize failed: 0x%08x\n", hr);
1277 ok(count == 3, "got %d expected 3\n", count);
1278
1279 count = 0;
1280 hr = ScriptItemize(test2, lstrlenW(test2), 5, NULL, NULL, items, &count);
1281 ok(hr == S_OK, "ScriptItemize failed: 0x%08x\n", hr);
1282 ok(count == 3, "got %d expected 3\n", count);
1283
1284 count = 0;
1285 hr = ScriptItemize(test3, lstrlenW(test3), 5, NULL, NULL, items, &count);
1286 ok(hr == S_OK, "ScriptItemize failed: 0x%08x\n", hr);
1287 ok(count == 4, "got %d expected 4\n", count);
1288
1289 count = 0;
1290 hr = ScriptItemize(test4, lstrlenW(test4), 5, NULL, NULL, items, &count);
1291 ok(hr == S_OK, "ScriptItemize failed: 0x%08x\n", hr);
1292 ok(count == 4, "got %d expected 4\n", count);
1293
1294 count = 0;
1295 hr = ScriptItemize(test5, lstrlenW(test5), 5, NULL, NULL, items, &count);
1296 ok(hr == S_OK, "ScriptItemize failed: 0x%08x\n", hr);
1297 ok(count == 4, "got %d expected 4\n", count);
1298 }
1299
1300 START_TEST(usp10)
1301 {
1302 HWND hwnd;
1303 HDC hdc;
1304 LOGFONTA lf;
1305 HFONT hfont;
1306
1307 unsigned short pwOutGlyphs[256];
1308
1309 /* We need a valid HDC to drive a lot of Script functions which requires the following *
1310 * to set up for the tests. */
1311 hwnd = CreateWindowExA(0, "static", "", WS_POPUP, 0,0,100,100,
1312 0, 0, 0, NULL);
1313 assert(hwnd != 0);
1314 ShowWindow(hwnd, SW_SHOW);
1315 UpdateWindow(hwnd);
1316
1317 hdc = GetDC(hwnd); /* We now have a hdc */
1318 ok( hdc != NULL, "HDC failed to be created %p\n", hdc);
1319
1320 memset(&lf, 0, sizeof(LOGFONTA));
1321 lstrcpyA(lf.lfFaceName, "Tahoma");
1322 lf.lfHeight = 10;
1323 lf.lfWeight = 3;
1324 lf.lfWidth = 10;
1325
1326 hfont = SelectObject(hdc, CreateFontIndirectA(&lf));
1327
1328 test_ScriptItemIzeShapePlace(hdc,pwOutGlyphs);
1329 test_ScriptGetCMap(hdc, pwOutGlyphs);
1330 test_ScriptCacheGetHeight(hdc);
1331 test_ScriptGetGlyphABCWidth(hdc);
1332 test_ScriptShape(hdc);
1333
1334 test_ScriptGetFontProperties(hdc);
1335 test_ScriptTextOut(hdc);
1336 test_ScriptTextOut2(hdc);
1337 test_ScriptXtoX();
1338 test_ScriptString(hdc);
1339 test_ScriptStringXtoCP_CPtoX(hdc);
1340
1341 test_ScriptLayout();
1342 test_digit_substitution();
1343 test_ScriptGetProperties();
1344 test_ScriptBreak();
1345 test_newlines();
1346
1347 ReleaseDC(hwnd, hdc);
1348 DestroyWindow(hwnd);
1349 }
A free Windows-compatible Operating System